[thirdparty/git.git] / usage.c

/*
 * GIT - The information manager from hell
 *
 * Copyright (C) Linus Torvalds, 2005
 */
#include "git-compat-util.h"
#include "cache.h"

void vreportf(const char *prefix, const char *err, va_list params)
{
	char msg[4096];
	char *p, *pend = msg + sizeof(msg);
	size_t prefix_len = strlen(prefix);

	if (sizeof(msg) <= prefix_len) {
		fprintf(stderr, "BUG!!! too long a prefix '%s'\n", prefix);
		abort();
	}
	memcpy(msg, prefix, prefix_len);
	p = msg + prefix_len;
	if (vsnprintf(p, pend - p, err, params) < 0)
		*p = '\0'; /* vsnprintf() failed, clip at prefix */

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

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

static NORETURN void usage_builtin(const char *err, va_list params)
{
	vreportf("usage: ", err, params);

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

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

	exit(129);
}

static NORETURN void die_builtin(const char *err, va_list params)
{
	/*
	 * We call this trace2 function first and expect it to va_copy 'params'
	 * before using it (because an 'ap' can only be walked once).
	 */
	trace2_cmd_error_va(err, params);

	vreportf("fatal: ", err, params);

	exit(128);
}

static void error_builtin(const char *err, va_list params)
{
	/*
	 * We call this trace2 function first and expect it to va_copy 'params'
	 * before using it (because an 'ap' can only be walked once).
	 */
	trace2_cmd_error_va(err, params);

	vreportf("error: ", err, params);
}

static void warn_builtin(const char *warn, va_list params)
{
	vreportf("warning: ", warn, params);
}

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

	dying++;
	if (dying > recursion_limit) {
		return 1;
	} else if (dying == 2) {
		warning("die() called many times. Recursion error or racy threaded death!");
		return 0;
	} else {
		return 0;
	}
}

/* If we are in a dlopen()ed .so write to a global variable would segfault
 * (ugh), so keep things static. */
static NORETURN_PTR void (*usage_routine)(const char *err, va_list params) = usage_builtin;
static NORETURN_PTR void (*die_routine)(const char *err, va_list params) = die_builtin;
static void (*error_routine)(const char *err, va_list params) = error_builtin;
static void (*warn_routine)(const char *err, va_list params) = warn_builtin;
static int (*die_is_recursing)(void) = die_is_recursing_builtin;

void set_die_routine(NORETURN_PTR void (*routine)(const char *err, va_list params))
{
	die_routine = routine;
}

void set_error_routine(void (*routine)(const char *err, va_list params))
{
	error_routine = routine;
}

void (*get_error_routine(void))(const char *err, va_list params)
{
	return error_routine;
}

void set_warn_routine(void (*routine)(const char *warn, va_list params))
{
	warn_routine = routine;
}

void (*get_warn_routine(void))(const char *warn, va_list params)
{
	return warn_routine;
}

void set_die_is_recursing_routine(int (*routine)(void))
{
	die_is_recursing = routine;
}

void NORETURN usagef(const char *err, ...)
{
	va_list params;

	va_start(params, err);
	usage_routine(err, params);
	va_end(params);
}

void NORETURN usage(const char *err)
{
	usagef("%s", err);
}

void NORETURN die(const char *err, ...)
{
	va_list params;

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

	va_start(params, err);
	die_routine(err, params);
	va_end(params);
}

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

	err = strerror(errno);
	for (i = j = 0; err[i] && j < sizeof(str_error) - 1; ) {
		if ((str_error[j++] = err[i++]) != '%')
			continue;
		if (j < sizeof(str_error) - 1) {
			str_error[j++] = '%';
		} else {
			/* No room to double the '%', so we overwrite it with
			 * '\0' below */
			j--;
			break;
		}
	}
	str_error[j] = 0;
	/* Truncation is acceptable here */
	snprintf(buf, n, "%s: %s", fmt, str_error);
	return buf;
}

void NORETURN die_errno(const char *fmt, ...)
{
	char buf[1024];
	va_list params;

	if (die_is_recursing()) {
		fputs("fatal: recursion detected in die_errno handler\n",
			stderr);
		exit(128);
	}

	va_start(params, fmt);
	die_routine(fmt_with_err(buf, sizeof(buf), fmt), params);
	va_end(params);
}

#undef error_errno
int error_errno(const char *fmt, ...)
{
	char buf[1024];
	va_list params;

	va_start(params, fmt);
	error_routine(fmt_with_err(buf, sizeof(buf), fmt), params);
	va_end(params);
	return -1;
}

#undef error
int error(const char *err, ...)
{
	va_list params;

	va_start(params, err);
	error_routine(err, params);
	va_end(params);
	return -1;
}

void warning_errno(const char *warn, ...)
{
	char buf[1024];
	va_list params;

	va_start(params, warn);
	warn_routine(fmt_with_err(buf, sizeof(buf), warn), params);
	va_end(params);
}

void warning(const char *warn, ...)
{
	va_list params;

	va_start(params, warn);
	warn_routine(warn, params);
	va_end(params);
}

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

static NORETURN void BUG_vfl(const char *file, int line, const char *fmt, va_list params)
{
	char prefix[256];

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

	vreportf(prefix, fmt, params);
	if (BUG_exit_code)
		exit(BUG_exit_code);
	abort();
}

#ifdef HAVE_VARIADIC_MACROS
NORETURN void BUG_fl(const char *file, int line, const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	BUG_vfl(file, line, fmt, ap);
	va_end(ap);
}
#else
NORETURN void BUG(const char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	BUG_vfl(NULL, 0, fmt, ap);
	va_end(ap);
}
#endif

#ifdef SUPPRESS_ANNOTATED_LEAKS
void unleak_memory(const void *ptr, size_t len)
{
	static struct suppressed_leak_root {
		struct suppressed_leak_root *next;
		char data[FLEX_ARRAY];
	} *suppressed_leaks;
	struct suppressed_leak_root *root;

	FLEX_ALLOC_MEM(root, data, ptr, len);
	root->next = suppressed_leaks;
	suppressed_leaks = root;
}
#endif
Commit	Line	Data
	1	/*
	2	* GIT - The information manager from hell
	3	*
	4	* Copyright (C) Linus Torvalds, 2005
	5	*/
	6	#include "git-compat-util.h"
	7	#include "cache.h"
	8
	9	void vreportf(const char prefix, const char err, va_list params)
	10	{
	11	char msg[4096];
	12	char p, pend = msg + sizeof(msg);
	13	size_t prefix_len = strlen(prefix);
	14
	15	if (sizeof(msg) <= prefix_len) {
	16	fprintf(stderr, "BUG!!! too long a prefix '%s'\n", prefix);
	17	abort();
	18	}
	19	memcpy(msg, prefix, prefix_len);
	20	p = msg + prefix_len;
	21	if (vsnprintf(p, pend - p, err, params) < 0)
	22	p = '\0'; / vsnprintf() failed, clip at prefix */
	23
	24	for (; p != pend - 1 && *p; p++) {
	25	if (iscntrl(p) && p != '\t' && *p != '\n')
	26	*p = '?';
	27	}
	28
	29	(p++) = '\n'; / we no longer need a NUL */
	30	fflush(stderr);
	31	write_in_full(2, msg, p - msg);
	32	}
	33
	34	static NORETURN void usage_builtin(const char *err, va_list params)
	35	{
	36	vreportf("usage: ", err, params);
	37
	38	/*
	39	* When we detect a usage error before the command dispatch in
	40	* cmd_main(), we don't know what verb to report. Force it to this
	41	* to facilitate post-processing.
	42	*/
	43	trace2_cmd_name("_usage_");
	44
	45	/*
	46	* Currently, the (err, params) are usually just the static usage
	47	* string which isn't very useful here. Usually, the call site
	48	* manually calls fprintf(stderr,...) with the actual detailed
	49	* syntax error before calling usage().
	50	*
	51	* TODO It would be nice to update the call sites to pass both
	52	* the static usage string and the detailed error message.
	53	*/
	54
	55	exit(129);
	56	}
	57
	58	static NORETURN void die_builtin(const char *err, va_list params)
	59	{
	60	/*
	61	* We call this trace2 function first and expect it to va_copy 'params'
	62	* before using it (because an 'ap' can only be walked once).
	63	*/
	64	trace2_cmd_error_va(err, params);
	65
	66	vreportf("fatal: ", err, params);
	67
	68	exit(128);
	69	}
	70
	71	static void error_builtin(const char *err, va_list params)
	72	{
	73	/*
	74	* We call this trace2 function first and expect it to va_copy 'params'
	75	* before using it (because an 'ap' can only be walked once).
	76	*/
	77	trace2_cmd_error_va(err, params);
	78
	79	vreportf("error: ", err, params);
	80	}
	81
	82	static void warn_builtin(const char *warn, va_list params)
	83	{
	84	vreportf("warning: ", warn, params);
	85	}
	86
	87	static int die_is_recursing_builtin(void)
	88	{
	89	static int dying;
	90	/*
	91	* Just an arbitrary number X where "a < x < b" where "a" is
	92	* "maximum number of pthreads we'll ever plausibly spawn" and
	93	* "b" is "something less than Inf", since the point is to
	94	* prevent infinite recursion.
	95	*/
	96	static const int recursion_limit = 1024;
	97
	98	dying++;
	99	if (dying > recursion_limit) {
	100	return 1;
	101	} else if (dying == 2) {
	102	warning("die() called many times. Recursion error or racy threaded death!");
	103	return 0;
	104	} else {
	105	return 0;
	106	}
	107	}
	108
	109	/* If we are in a dlopen()ed .so write to a global variable would segfault
	110	* (ugh), so keep things static. */
	111	static NORETURN_PTR void (usage_routine)(const char err, va_list params) = usage_builtin;
	112	static NORETURN_PTR void (die_routine)(const char err, va_list params) = die_builtin;
	113	static void (error_routine)(const char err, va_list params) = error_builtin;
	114	static void (warn_routine)(const char err, va_list params) = warn_builtin;
	115	static int (*die_is_recursing)(void) = die_is_recursing_builtin;
	116
	117	void set_die_routine(NORETURN_PTR void (routine)(const char err, va_list params))
	118	{
	119	die_routine = routine;
	120	}
	121
	122	void set_error_routine(void (routine)(const char err, va_list params))
	123	{
	124	error_routine = routine;
	125	}
	126
	127	void (get_error_routine(void))(const char err, va_list params)
	128	{
	129	return error_routine;
	130	}
	131
	132	void set_warn_routine(void (routine)(const char warn, va_list params))
	133	{
	134	warn_routine = routine;
	135	}
	136
	137	void (get_warn_routine(void))(const char warn, va_list params)
	138	{
	139	return warn_routine;
	140	}
	141
	142	void set_die_is_recursing_routine(int (*routine)(void))
	143	{
	144	die_is_recursing = routine;
	145	}
	146
	147	void NORETURN usagef(const char *err, ...)
	148	{
	149	va_list params;
	150
	151	va_start(params, err);
	152	usage_routine(err, params);
	153	va_end(params);
	154	}
	155
	156	void NORETURN usage(const char *err)
	157	{
	158	usagef("%s", err);
	159	}
	160
	161	void NORETURN die(const char *err, ...)
	162	{
	163	va_list params;
	164
	165	if (die_is_recursing()) {
	166	fputs("fatal: recursion detected in die handler\n", stderr);
	167	exit(128);
	168	}
	169
	170	va_start(params, err);
	171	die_routine(err, params);
	172	va_end(params);
	173	}
	174
	175	static const char fmt_with_err(char buf, int n, const char *fmt)
	176	{
	177	char str_error[256], *err;
	178	int i, j;
	179
	180	err = strerror(errno);
	181	for (i = j = 0; err[i] && j < sizeof(str_error) - 1; ) {
	182	if ((str_error[j++] = err[i++]) != '%')
	183	continue;
	184	if (j < sizeof(str_error) - 1) {
	185	str_error[j++] = '%';
	186	} else {
	187	/* No room to double the '%', so we overwrite it with
	188	* '\0' below */
	189	j--;
	190	break;
	191	}
	192	}
	193	str_error[j] = 0;
	194	/* Truncation is acceptable here */
	195	snprintf(buf, n, "%s: %s", fmt, str_error);
	196	return buf;
	197	}
	198
	199	void NORETURN die_errno(const char *fmt, ...)
	200	{
	201	char buf[1024];
	202	va_list params;
	203
	204	if (die_is_recursing()) {
	205	fputs("fatal: recursion detected in die_errno handler\n",
	206	stderr);
	207	exit(128);
	208	}
	209
	210	va_start(params, fmt);
	211	die_routine(fmt_with_err(buf, sizeof(buf), fmt), params);
	212	va_end(params);
	213	}
	214
	215	#undef error_errno
	216	int error_errno(const char *fmt, ...)
	217	{
	218	char buf[1024];
	219	va_list params;
	220
	221	va_start(params, fmt);
	222	error_routine(fmt_with_err(buf, sizeof(buf), fmt), params);
	223	va_end(params);
	224	return -1;
	225	}
	226
	227	#undef error
	228	int error(const char *err, ...)
	229	{
	230	va_list params;
	231
	232	va_start(params, err);
	233	error_routine(err, params);
	234	va_end(params);
	235	return -1;
	236	}
	237
	238	void warning_errno(const char *warn, ...)
	239	{
	240	char buf[1024];
	241	va_list params;
	242
	243	va_start(params, warn);
	244	warn_routine(fmt_with_err(buf, sizeof(buf), warn), params);
	245	va_end(params);
	246	}
	247
	248	void warning(const char *warn, ...)
	249	{
	250	va_list params;
	251
	252	va_start(params, warn);
	253	warn_routine(warn, params);
	254	va_end(params);
	255	}
	256
	257	/* Only set this, ever, from t/helper/, when verifying that bugs are caught. */
	258	int BUG_exit_code;
	259
	260	static NORETURN void BUG_vfl(const char file, int line, const char fmt, va_list params)
	261	{
	262	char prefix[256];
	263
	264	/* truncation via snprintf is OK here */
	265	if (file)
	266	snprintf(prefix, sizeof(prefix), "BUG: %s:%d: ", file, line);
	267	else
	268	snprintf(prefix, sizeof(prefix), "BUG: ");
	269
	270	vreportf(prefix, fmt, params);
	271	if (BUG_exit_code)
	272	exit(BUG_exit_code);
	273	abort();
	274	}
	275
	276	#ifdef HAVE_VARIADIC_MACROS
	277	NORETURN void BUG_fl(const char file, int line, const char fmt, ...)
	278	{
	279	va_list ap;
	280	va_start(ap, fmt);
	281	BUG_vfl(file, line, fmt, ap);
	282	va_end(ap);
	283	}
	284	#else
	285	NORETURN void BUG(const char *fmt, ...)
	286	{
	287	va_list ap;
	288	va_start(ap, fmt);
	289	BUG_vfl(NULL, 0, fmt, ap);
	290	va_end(ap);
	291	}
	292	#endif
	293
	294	#ifdef SUPPRESS_ANNOTATED_LEAKS
	295	void unleak_memory(const void *ptr, size_t len)
	296	{
	297	static struct suppressed_leak_root {
	298	struct suppressed_leak_root *next;
	299	char data[FLEX_ARRAY];
	300	} *suppressed_leaks;
	301	struct suppressed_leak_root *root;
	302
	303	FLEX_ALLOC_MEM(root, data, ptr, len);
	304	root->next = suppressed_leaks;
	305	suppressed_leaks = root;
	306	}
	307	#endif