Linus Torvalds | 0fcfd16 | 2005-04-18 13:04:43 -0700 | [diff] [blame] | 1 | /* |
| 2 | * GIT - The information manager from hell |
| 3 | * |
| 4 | * Copyright (C) Linus Torvalds, 2005 |
| 5 | */ |
Junio C Hamano | 4050c0d | 2005-12-05 11:54:29 -0800 | [diff] [blame] | 6 | #include "git-compat-util.h" |
Clemens Buchacher | 3bc4181 | 2011-07-27 23:32:34 +0200 | [diff] [blame] | 7 | #include "cache.h" |
Linus Torvalds | 0fcfd16 | 2005-04-18 13:04:43 -0700 | [diff] [blame] | 8 | |
Johannes Sixt | ebaa79f | 2010-03-06 16:40:39 +0100 | [diff] [blame] | 9 | void vreportf(const char *prefix, const char *err, va_list params) |
Linus Torvalds | 0fcfd16 | 2005-04-18 13:04:43 -0700 | [diff] [blame] | 10 | { |
Björn Gustavsson | 625a860 | 2009-11-22 22:19:53 +0100 | [diff] [blame] | 11 | char msg[4096]; |
Nicolas Pitre | d048a96 | 2007-11-09 14:33:54 -0500 | [diff] [blame] | 12 | vsnprintf(msg, sizeof(msg), err, params); |
| 13 | fprintf(stderr, "%s%s\n", prefix, msg); |
Linus Torvalds | 0fcfd16 | 2005-04-18 13:04:43 -0700 | [diff] [blame] | 14 | } |
| 15 | |
Clemens Buchacher | 3bc4181 | 2011-07-27 23:32:34 +0200 | [diff] [blame] | 16 | void vwritef(int fd, const char *prefix, const char *err, va_list params) |
| 17 | { |
| 18 | char msg[4096]; |
| 19 | int len = vsnprintf(msg, sizeof(msg), err, params); |
| 20 | if (len > sizeof(msg)) |
| 21 | len = sizeof(msg); |
| 22 | |
| 23 | write_in_full(fd, prefix, strlen(prefix)); |
| 24 | write_in_full(fd, msg, len); |
| 25 | write_in_full(fd, "\n", 1); |
| 26 | } |
| 27 | |
Jonathan Nieder | 64b1cb7 | 2009-11-09 09:05:02 -0600 | [diff] [blame] | 28 | static NORETURN void usage_builtin(const char *err, va_list params) |
Linus Torvalds | 0fcfd16 | 2005-04-18 13:04:43 -0700 | [diff] [blame] | 29 | { |
Johannes Sixt | ebaa79f | 2010-03-06 16:40:39 +0100 | [diff] [blame] | 30 | vreportf("usage: ", err, params); |
Linus Torvalds | 5d1a5c0 | 2005-10-01 13:24:27 -0700 | [diff] [blame] | 31 | exit(129); |
Linus Torvalds | 0fcfd16 | 2005-04-18 13:04:43 -0700 | [diff] [blame] | 32 | } |
| 33 | |
Junio C Hamano | ce88ac5 | 2006-06-23 22:44:33 -0700 | [diff] [blame] | 34 | static NORETURN void die_builtin(const char *err, va_list params) |
Petr Baudis | 39a3f5e | 2006-06-24 04:34:38 +0200 | [diff] [blame] | 35 | { |
Johannes Sixt | ebaa79f | 2010-03-06 16:40:39 +0100 | [diff] [blame] | 36 | vreportf("fatal: ", err, params); |
Petr Baudis | 39a3f5e | 2006-06-24 04:34:38 +0200 | [diff] [blame] | 37 | exit(128); |
| 38 | } |
| 39 | |
Junio C Hamano | ce88ac5 | 2006-06-23 22:44:33 -0700 | [diff] [blame] | 40 | static void error_builtin(const char *err, va_list params) |
Petr Baudis | 39a3f5e | 2006-06-24 04:34:38 +0200 | [diff] [blame] | 41 | { |
Johannes Sixt | ebaa79f | 2010-03-06 16:40:39 +0100 | [diff] [blame] | 42 | vreportf("error: ", err, params); |
Petr Baudis | 39a3f5e | 2006-06-24 04:34:38 +0200 | [diff] [blame] | 43 | } |
| 44 | |
Shawn O. Pearce | fa39b6b | 2006-12-21 19:48:32 -0500 | [diff] [blame] | 45 | static void warn_builtin(const char *warn, va_list params) |
| 46 | { |
Johannes Sixt | ebaa79f | 2010-03-06 16:40:39 +0100 | [diff] [blame] | 47 | vreportf("warning: ", warn, params); |
Shawn O. Pearce | fa39b6b | 2006-12-21 19:48:32 -0500 | [diff] [blame] | 48 | } |
Petr Baudis | 39a3f5e | 2006-06-24 04:34:38 +0200 | [diff] [blame] | 49 | |
Jeff King | c19a490 | 2013-04-16 15:46:22 -0400 | [diff] [blame] | 50 | static int die_is_recursing_builtin(void) |
| 51 | { |
| 52 | static int dying; |
| 53 | return dying++; |
| 54 | } |
| 55 | |
Petr Baudis | 39a3f5e | 2006-06-24 04:34:38 +0200 | [diff] [blame] | 56 | /* If we are in a dlopen()ed .so write to a global variable would segfault |
| 57 | * (ugh), so keep things static. */ |
Jonathan Nieder | 64b1cb7 | 2009-11-09 09:05:02 -0600 | [diff] [blame] | 58 | static NORETURN_PTR void (*usage_routine)(const char *err, va_list params) = usage_builtin; |
Erik Faye-Lund | 18660bc | 2009-09-30 18:05:50 +0000 | [diff] [blame] | 59 | static NORETURN_PTR void (*die_routine)(const char *err, va_list params) = die_builtin; |
Petr Baudis | 39a3f5e | 2006-06-24 04:34:38 +0200 | [diff] [blame] | 60 | static void (*error_routine)(const char *err, va_list params) = error_builtin; |
Shawn O. Pearce | fa39b6b | 2006-12-21 19:48:32 -0500 | [diff] [blame] | 61 | static void (*warn_routine)(const char *err, va_list params) = warn_builtin; |
Jeff King | c19a490 | 2013-04-16 15:46:22 -0400 | [diff] [blame] | 62 | static int (*die_is_recursing)(void) = die_is_recursing_builtin; |
Petr Baudis | 39a3f5e | 2006-06-24 04:34:38 +0200 | [diff] [blame] | 63 | |
Erik Faye-Lund | 18660bc | 2009-09-30 18:05:50 +0000 | [diff] [blame] | 64 | void set_die_routine(NORETURN_PTR void (*routine)(const char *err, va_list params)) |
Petr Baudis | 39a3f5e | 2006-06-24 04:34:38 +0200 | [diff] [blame] | 65 | { |
| 66 | die_routine = routine; |
| 67 | } |
| 68 | |
Clemens Buchacher | 3bc4181 | 2011-07-27 23:32:34 +0200 | [diff] [blame] | 69 | void set_error_routine(void (*routine)(const char *err, va_list params)) |
| 70 | { |
| 71 | error_routine = routine; |
| 72 | } |
| 73 | |
Jeff King | c19a490 | 2013-04-16 15:46:22 -0400 | [diff] [blame] | 74 | void set_die_is_recursing_routine(int (*routine)(void)) |
| 75 | { |
| 76 | die_is_recursing = routine; |
| 77 | } |
| 78 | |
Stephen Boyd | c2e86ad | 2011-03-22 00:51:05 -0700 | [diff] [blame] | 79 | void NORETURN usagef(const char *err, ...) |
Jonathan Nieder | 64b1cb7 | 2009-11-09 09:05:02 -0600 | [diff] [blame] | 80 | { |
| 81 | va_list params; |
| 82 | |
| 83 | va_start(params, err); |
| 84 | usage_routine(err, params); |
| 85 | va_end(params); |
| 86 | } |
| 87 | |
Stephen Boyd | c2e86ad | 2011-03-22 00:51:05 -0700 | [diff] [blame] | 88 | void NORETURN usage(const char *err) |
Petr Baudis | 39a3f5e | 2006-06-24 04:34:38 +0200 | [diff] [blame] | 89 | { |
Jonathan Nieder | 64b1cb7 | 2009-11-09 09:05:02 -0600 | [diff] [blame] | 90 | usagef("%s", err); |
Petr Baudis | 39a3f5e | 2006-06-24 04:34:38 +0200 | [diff] [blame] | 91 | } |
| 92 | |
Stephen Boyd | c2e86ad | 2011-03-22 00:51:05 -0700 | [diff] [blame] | 93 | void NORETURN die(const char *err, ...) |
Linus Torvalds | 0fcfd16 | 2005-04-18 13:04:43 -0700 | [diff] [blame] | 94 | { |
| 95 | va_list params; |
| 96 | |
Jeff King | c19a490 | 2013-04-16 15:46:22 -0400 | [diff] [blame] | 97 | if (die_is_recursing()) { |
Brandon Casey | cd163d4 | 2012-11-14 17:45:52 -0800 | [diff] [blame] | 98 | fputs("fatal: recursion detected in die handler\n", stderr); |
| 99 | exit(128); |
| 100 | } |
Brandon Casey | cd163d4 | 2012-11-14 17:45:52 -0800 | [diff] [blame] | 101 | |
Linus Torvalds | 0fcfd16 | 2005-04-18 13:04:43 -0700 | [diff] [blame] | 102 | va_start(params, err); |
Petr Baudis | 39a3f5e | 2006-06-24 04:34:38 +0200 | [diff] [blame] | 103 | die_routine(err, params); |
Linus Torvalds | 0fcfd16 | 2005-04-18 13:04:43 -0700 | [diff] [blame] | 104 | va_end(params); |
Linus Torvalds | 0fcfd16 | 2005-04-18 13:04:43 -0700 | [diff] [blame] | 105 | } |
| 106 | |
Stephen Boyd | c2e86ad | 2011-03-22 00:51:05 -0700 | [diff] [blame] | 107 | void NORETURN die_errno(const char *fmt, ...) |
Thomas Rast | b875036 | 2009-06-27 17:58:44 +0200 | [diff] [blame] | 108 | { |
| 109 | va_list params; |
| 110 | char fmt_with_err[1024]; |
Junio C Hamano | f8b5a8e | 2009-06-27 17:58:45 +0200 | [diff] [blame] | 111 | char str_error[256], *err; |
| 112 | int i, j; |
Thomas Rast | b875036 | 2009-06-27 17:58:44 +0200 | [diff] [blame] | 113 | |
Jeff King | c19a490 | 2013-04-16 15:46:22 -0400 | [diff] [blame] | 114 | if (die_is_recursing()) { |
Brandon Casey | cd163d4 | 2012-11-14 17:45:52 -0800 | [diff] [blame] | 115 | fputs("fatal: recursion detected in die_errno handler\n", |
| 116 | stderr); |
| 117 | exit(128); |
| 118 | } |
Brandon Casey | cd163d4 | 2012-11-14 17:45:52 -0800 | [diff] [blame] | 119 | |
Junio C Hamano | f8b5a8e | 2009-06-27 17:58:45 +0200 | [diff] [blame] | 120 | err = strerror(errno); |
| 121 | for (i = j = 0; err[i] && j < sizeof(str_error) - 1; ) { |
| 122 | if ((str_error[j++] = err[i++]) != '%') |
| 123 | continue; |
| 124 | if (j < sizeof(str_error) - 1) { |
| 125 | str_error[j++] = '%'; |
| 126 | } else { |
| 127 | /* No room to double the '%', so we overwrite it with |
| 128 | * '\0' below */ |
| 129 | j--; |
| 130 | break; |
| 131 | } |
| 132 | } |
| 133 | str_error[j] = 0; |
| 134 | snprintf(fmt_with_err, sizeof(fmt_with_err), "%s: %s", fmt, str_error); |
Thomas Rast | b875036 | 2009-06-27 17:58:44 +0200 | [diff] [blame] | 135 | |
| 136 | va_start(params, fmt); |
| 137 | die_routine(fmt_with_err, params); |
| 138 | va_end(params); |
| 139 | } |
| 140 | |
Jeff King | e208f9c | 2012-12-15 12:37:36 -0500 | [diff] [blame] | 141 | #undef error |
Linus Torvalds | 0fcfd16 | 2005-04-18 13:04:43 -0700 | [diff] [blame] | 142 | int error(const char *err, ...) |
| 143 | { |
| 144 | va_list params; |
| 145 | |
| 146 | va_start(params, err); |
Petr Baudis | 39a3f5e | 2006-06-24 04:34:38 +0200 | [diff] [blame] | 147 | error_routine(err, params); |
Linus Torvalds | 0fcfd16 | 2005-04-18 13:04:43 -0700 | [diff] [blame] | 148 | va_end(params); |
| 149 | return -1; |
| 150 | } |
Shawn O. Pearce | fa39b6b | 2006-12-21 19:48:32 -0500 | [diff] [blame] | 151 | |
Theodore Ts'o | 46efd2d | 2007-03-30 19:07:05 -0400 | [diff] [blame] | 152 | void warning(const char *warn, ...) |
Shawn O. Pearce | fa39b6b | 2006-12-21 19:48:32 -0500 | [diff] [blame] | 153 | { |
| 154 | va_list params; |
| 155 | |
| 156 | va_start(params, warn); |
| 157 | warn_routine(warn, params); |
| 158 | va_end(params); |
| 159 | } |