log.c

   1 /*
   2
   3 Shared versions of debug(), log(), etc.
   4
   5 */
   6
   7 #include "includes.h"
   8 RCSID("$OpenBSD: log.c,v 1.1 1999/11/10 23:36:44 markus Exp $");
   9
  10 #include "ssh.h"
  11 #include "xmalloc.h"
  12
  13 /* Fatal messages.  This function never returns. */
  14
  15 void
  16 fatal(const char *fmt, ...)
  17 {
  18   va_list args;
  19   va_start(args, fmt);
  20   do_log(SYSLOG_LEVEL_FATAL, fmt, args);
  21   va_end(args);
  22   fatal_cleanup();
  23 }
  24
  25 /* Error messages that should be logged. */
  26
  27 void
  28 error(const char *fmt, ...)
  29 {
  30   va_list args;
  31   va_start(args, fmt);
  32   do_log(SYSLOG_LEVEL_ERROR, fmt, args);
  33   va_end(args);
  34 }
  35
  36 /* Log this message (information that usually should go to the log). */
  37
  38 void
  39 log(const char *fmt, ...)
  40 {
  41   va_list args;
  42   va_start(args, fmt);
  43   do_log(SYSLOG_LEVEL_INFO, fmt, args);
  44   va_end(args);
  45 }
  46
  47 /* More detailed messages (information that does not need to go to the log). */
  48
  49 void
  50 chat(const char *fmt, ...)
  51 {
  52   va_list args;
  53   va_start(args, fmt);
  54   do_log(SYSLOG_LEVEL_CHAT, fmt, args);
  55   va_end(args);
  56 }
  57
  58 /* Debugging messages that should not be logged during normal operation. */
  59
  60 void
  61 debug(const char *fmt, ...)
  62 {
  63   va_list args;
  64   va_start(args, fmt);
  65   do_log(SYSLOG_LEVEL_DEBUG, fmt, args);
  66   va_end(args);
  67 }
  68
  69 /* Fatal cleanup */
  70
  71 struct fatal_cleanup
  72 {
  73   struct fatal_cleanup *next;
  74   void (*proc)(void *);
  75   void *context;
  76 };
  77
  78 static struct fatal_cleanup *fatal_cleanups = NULL;
  79
  80 /* Registers a cleanup function to be called by fatal() before exiting. */
  81
  82 void
  83 fatal_add_cleanup(void (*proc)(void *), void *context)
  84 {
  85   struct fatal_cleanup *cu;
  86
  87   cu = xmalloc(sizeof(*cu));
  88   cu->proc = proc;
  89   cu->context = context;
  90   cu->next = fatal_cleanups;
  91   fatal_cleanups = cu;
  92 }
  93
  94 /* Removes a cleanup frunction to be called at fatal(). */
  95
  96 void
  97 fatal_remove_cleanup(void (*proc)(void *context), void *context)
  98 {
  99   struct fatal_cleanup **cup, *cu;
 100
 101   for (cup = &fatal_cleanups; *cup; cup = &cu->next)
 102     {
 103       cu = *cup;
 104       if (cu->proc == proc && cu->context == context)
 105         {
 106           *cup = cu->next;
 107           xfree(cu);
 108           return;
 109         }
 110     }
 111   fatal("fatal_remove_cleanup: no such cleanup function: 0x%lx 0x%lx\n",
 112         (unsigned long)proc, (unsigned long)context);
 113 }
 114
 115 /* Cleanup and exit */
 116 void
 117 fatal_cleanup(void)
 118 {
 119   struct fatal_cleanup *cu, *next_cu;
 120   static int called = 0;
 121   if (called)
 122     exit(255);
 123   called = 1;
 124
 125   /* Call cleanup functions. */
 126   for (cu = fatal_cleanups; cu; cu = next_cu)
 127     {
 128       next_cu = cu->next;
 129       debug("Calling cleanup 0x%lx(0x%lx)",
 130             (unsigned long)cu->proc, (unsigned long)cu->context);
 131       (*cu->proc)(cu->context);
 132     }
 133
 134   exit(255);
 135 }