git

1
/*
2
 * GIT - The information manager from hell
3
 *
4
 * Copyright (C) Linus Torvalds, 2005
5
 */
6
#include "git-compat-util.h"
7
#include "gettext.h"
8
#include "trace2.h"
9

10
static void vreportf(const char *prefix, const char *err, va_list params)
11
{
12
	char msg[4096];
13
	char *p, *pend = msg + sizeof(msg);
14
	size_t prefix_len = strlen(prefix);
15

16
	if (sizeof(msg) <= prefix_len) {
17
		fprintf(stderr, "BUG!!! too long a prefix '%s'\n", prefix);
18
		abort();
19
	}
20
	memcpy(msg, prefix, prefix_len);
21
	p = msg + prefix_len;
22
	if (vsnprintf(p, pend - p, err, params) < 0) {
23
		fprintf(stderr, _("error: unable to format message: %s\n"),
24
			err);
25
		*p = '\0'; /* vsnprintf() failed, clip at prefix */
26
	}
27

28
	for (; p != pend - 1 && *p; p++) {
29
		if (iscntrl(*p) && *p != '\t' && *p != '\n')
30
			*p = '?';
31
	}
32

33
	*(p++) = '\n'; /* we no longer need a NUL */
34
	fflush(stderr);
35
	write_in_full(2, msg, p - msg);
36
}
37

38
static NORETURN void usage_builtin(const char *err, va_list params)
39
{
40
	vreportf(_("usage: "), err, params);
41

42
	/*
43
	 * When we detect a usage error *before* the command dispatch in
44
	 * cmd_main(), we don't know what verb to report.  Force it to this
45
	 * to facilitate post-processing.
46
	 */
47
	trace2_cmd_name("_usage_");
48

49
	/*
50
	 * Currently, the (err, params) are usually just the static usage
51
	 * string which isn't very useful here.  Usually, the call site
52
	 * manually calls fprintf(stderr,...) with the actual detailed
53
	 * syntax error before calling usage().
54
	 *
55
	 * TODO It would be nice to update the call sites to pass both
56
	 * the static usage string and the detailed error message.
57
	 */
58

59
	exit(129);
60
}
61

62
static void die_message_builtin(const char *err, va_list params)
63
{
64
	trace2_cmd_error_va(err, params);
65
	vreportf(_("fatal: "), err, params);
66
}
67

68
/*
69
 * We call trace2_cmd_error_va() in the below functions first and
70
 * expect it to va_copy 'params' before using it (because an 'ap' can
71
 * only be walked once).
72
 */
73
static NORETURN void die_builtin(const char *err, va_list params)
74
{
75
	report_fn die_message_fn = get_die_message_routine();
76

77
	die_message_fn(err, params);
78
	exit(128);
79
}
80

81
static void error_builtin(const char *err, va_list params)
82
{
83
	trace2_cmd_error_va(err, params);
84

85
	vreportf(_("error: "), err, params);
86
}
87

88
static void warn_builtin(const char *warn, va_list params)
89
{
90
	trace2_cmd_error_va(warn, params);
91

92
	vreportf(_("warning: "), warn, params);
93
}
94

95
static int die_is_recursing_builtin(void)
96
{
97
	static int dying;
98
	/*
99
	 * Just an arbitrary number X where "a < x < b" where "a" is
100
	 * "maximum number of pthreads we'll ever plausibly spawn" and
101
	 * "b" is "something less than Inf", since the point is to
102
	 * prevent infinite recursion.
103
	 */
104
	static const int recursion_limit = 1024;
105

106
	dying++;
107
	if (dying > recursion_limit) {
108
		return 1;
109
	} else if (dying == 2) {
110
		warning("die() called many times. Recursion error or racy threaded death!");
111
		return 0;
112
	} else {
113
		return 0;
114
	}
115
}
116

117
/* If we are in a dlopen()ed .so write to a global variable would segfault
118
 * (ugh), so keep things static. */
119
static NORETURN_PTR report_fn usage_routine = usage_builtin;
120
static NORETURN_PTR report_fn die_routine = die_builtin;
121
static report_fn die_message_routine = die_message_builtin;
122
static report_fn error_routine = error_builtin;
123
static report_fn warn_routine = warn_builtin;
124
static int (*die_is_recursing)(void) = die_is_recursing_builtin;
125

126
void set_die_routine(NORETURN_PTR report_fn routine)
127
{
128
	die_routine = routine;
129
}
130

131
report_fn get_die_message_routine(void)
132
{
133
	return die_message_routine;
134
}
135

136
void set_error_routine(report_fn routine)
137
{
138
	error_routine = routine;
139
}
140

141
report_fn get_error_routine(void)
142
{
143
	return error_routine;
144
}
145

146
void set_warn_routine(report_fn routine)
147
{
148
	warn_routine = routine;
149
}
150

151
report_fn get_warn_routine(void)
152
{
153
	return warn_routine;
154
}
155

156
void set_die_is_recursing_routine(int (*routine)(void))
157
{
158
	die_is_recursing = routine;
159
}
160

161
void NORETURN usagef(const char *err, ...)
162
{
163
	va_list params;
164

165
	va_start(params, err);
166
	usage_routine(err, params);
167
	va_end(params);
168
}
169

170
void NORETURN usage(const char *err)
171
{
172
	usagef("%s", err);
173
}
174

175
void NORETURN die(const char *err, ...)
176
{
177
	va_list params;
178

179
	if (die_is_recursing()) {
180
		fputs("fatal: recursion detected in die handler\n", stderr);
181
		exit(128);
182
	}
183

184
	va_start(params, err);
185
	die_routine(err, params);
186
	va_end(params);
187
}
188

189
static const char *fmt_with_err(char *buf, int n, const char *fmt)
190
{
191
	char str_error[256], *err;
192
	int i, j;
193

194
	err = strerror(errno);
195
	for (i = j = 0; err[i] && j < sizeof(str_error) - 1; ) {
196
		if ((str_error[j++] = err[i++]) != '%')
197
			continue;
198
		if (j < sizeof(str_error) - 1) {
199
			str_error[j++] = '%';
200
		} else {
201
			/* No room to double the '%', so we overwrite it with
202
			 * '\0' below */
203
			j--;
204
			break;
205
		}
206
	}
207
	str_error[j] = 0;
208
	/* Truncation is acceptable here */
209
	snprintf(buf, n, "%s: %s", fmt, str_error);
210
	return buf;
211
}
212

213
void NORETURN die_errno(const char *fmt, ...)
214
{
215
	char buf[1024];
216
	va_list params;
217

218
	if (die_is_recursing()) {
219
		fputs("fatal: recursion detected in die_errno handler\n",
220
			stderr);
221
		exit(128);
222
	}
223

224
	va_start(params, fmt);
225
	die_routine(fmt_with_err(buf, sizeof(buf), fmt), params);
226
	va_end(params);
227
}
228

229
#undef die_message
230
int die_message(const char *err, ...)
231
{
232
	va_list params;
233

234
	va_start(params, err);
235
	die_message_routine(err, params);
236
	va_end(params);
237
	return 128;
238
}
239

240
#undef die_message_errno
241
int die_message_errno(const char *fmt, ...)
242
{
243
	char buf[1024];
244
	va_list params;
245

246
	va_start(params, fmt);
247
	die_message_routine(fmt_with_err(buf, sizeof(buf), fmt), params);
248
	va_end(params);
249
	return 128;
250
}
251

252
#undef error_errno
253
int error_errno(const char *fmt, ...)
254
{
255
	char buf[1024];
256
	va_list params;
257

258
	va_start(params, fmt);
259
	error_routine(fmt_with_err(buf, sizeof(buf), fmt), params);
260
	va_end(params);
261
	return -1;
262
}
263

264
#undef error
265
int error(const char *err, ...)
266
{
267
	va_list params;
268

269
	va_start(params, err);
270
	error_routine(err, params);
271
	va_end(params);
272
	return -1;
273
}
274

275
void warning_errno(const char *warn, ...)
276
{
277
	char buf[1024];
278
	va_list params;
279

280
	va_start(params, warn);
281
	warn_routine(fmt_with_err(buf, sizeof(buf), warn), params);
282
	va_end(params);
283
}
284

285
void warning(const char *warn, ...)
286
{
287
	va_list params;
288

289
	va_start(params, warn);
290
	warn_routine(warn, params);
291
	va_end(params);
292
}
293

294
/* Only set this, ever, from t/helper/, when verifying that bugs are caught. */
295
int BUG_exit_code;
296

297
static void BUG_vfl_common(const char *file, int line, const char *fmt,
298
			   va_list params)
299
{
300
	char prefix[256];
301

302
	/* truncation via snprintf is OK here */
303
	snprintf(prefix, sizeof(prefix), "BUG: %s:%d: ", file, line);
304

305
	vreportf(prefix, fmt, params);
306
}
307

308
static NORETURN void BUG_vfl(const char *file, int line, const char *fmt, va_list params)
309
{
310
	va_list params_copy;
311
	static int in_bug;
312

313
	va_copy(params_copy, params);
314
	BUG_vfl_common(file, line, fmt, params);
315

316
	if (in_bug)
317
		abort();
318
	in_bug = 1;
319

320
	trace2_cmd_error_va(fmt, params_copy);
321

322
	if (BUG_exit_code)
323
		exit(BUG_exit_code);
324
	abort();
325
}
326

327
NORETURN void BUG_fl(const char *file, int line, const char *fmt, ...)
328
{
329
	va_list ap;
330

331
	bug_called_must_BUG = 0;
332

333
	va_start(ap, fmt);
334
	BUG_vfl(file, line, fmt, ap);
335
	va_end(ap);
336
}
337

338
int bug_called_must_BUG;
339
void bug_fl(const char *file, int line, const char *fmt, ...)
340
{
341
	va_list ap;
342

343
	bug_called_must_BUG = 1;
344

345
	va_start(ap, fmt);
346
	BUG_vfl_common(file, line, fmt, ap);
347
	va_end(ap);
348

349
	va_start(ap, fmt);
350
	trace2_cmd_error_va(fmt, ap);
351
	va_end(ap);
352
}
353

354
#ifdef SUPPRESS_ANNOTATED_LEAKS
355
void unleak_memory(const void *ptr, size_t len)
356
{
357
	static struct suppressed_leak_root {
358
		struct suppressed_leak_root *next;
359
		char data[FLEX_ARRAY];
360
	} *suppressed_leaks;
361
	struct suppressed_leak_root *root;
362

363
	FLEX_ALLOC_MEM(root, data, ptr, len);
364
	root->next = suppressed_leaks;
365
	suppressed_leaks = root;
366
}
367
#endif
368