write_index_as_tree: cleanup tempfile on error

diff --git a/usage.c b/usage.c
index 1dad03fb5c9b7f8f7785915d004aff43e39b0d2a..1ea7df9a202339972ee59f35a5ba8852502c915f 100644 (file)
--- a/usage.c
+++ b/usage.c
@@ -6,22 +6,17 @@
 #include "git-compat-util.h"
 #include "cache.h"
 
-static FILE *error_handle;
-static int tweaked_error_buffering;
-
 void vreportf(const char *prefix, const char *err, va_list params)
 {
-       FILE *fh = error_handle ? error_handle : stderr;
+       char msg[4096];
+       char *p;
 
-       fflush(fh);
-       if (!tweaked_error_buffering) {
-               setvbuf(fh, NULL, _IOLBF, 0);
-               tweaked_error_buffering = 1;
+       vsnprintf(msg, sizeof(msg), err, params);
+       for (p = msg; *p; p++) {
+               if (iscntrl(*p) && *p != '\t' && *p != '\n')
+                       *p = '?';
        }
-
-       fputs(prefix, fh);
-       vfprintf(fh, err, params);
-       fputc('\n', fh);
+       fprintf(stderr, "%s%s\n", prefix, msg);
 }
 
 static NORETURN void usage_builtin(const char *err, va_list params)
@@ -49,7 +44,23 @@ static void warn_builtin(const char *warn, va_list params)
 static int die_is_recursing_builtin(void)
 {
        static int dying;
-       return 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
@@ -70,15 +81,24 @@ void set_error_routine(void (*routine)(const char *err, va_list params))
        error_routine = routine;
 }
 
-void set_die_is_recursing_routine(int (*routine)(void))
+void (*get_error_routine(void))(const char *err, va_list params)
 {
-       die_is_recursing = routine;
+       return error_routine;
+}
+
+void set_warn_routine(void (*routine)(const char *warn, va_list params))
+{
+       warn_routine = routine;
 }
 
-void set_error_handle(FILE *fh)
+void (*get_warn_routine(void))(const char *warn, va_list params)
 {
-       error_handle = fh;
-       tweaked_error_buffering = 0;
+       return warn_routine;
+}
+
+void set_die_is_recursing_routine(int (*routine)(void))
+{
+       die_is_recursing = routine;
 }
 
 void NORETURN usagef(const char *err, ...)
@@ -148,6 +168,7 @@ void NORETURN die_errno(const char *fmt, ...)
        va_end(params);
 }
 
+#undef error_errno
 int error_errno(const char *fmt, ...)
 {
        char buf[1024];
@@ -188,3 +209,35 @@ void warning(const char *warn, ...)
        warn_routine(warn, params);
        va_end(params);
 }
+
+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);
+       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