Return to log.c CVS log

Up to [local] / src / usr.bin / ssh

Annotation of src/usr.bin/ssh/log.c, Revision 1.1

1.1     ! markus      1: /*
        !             2:
        !             3: Shared versions of debug(), log(), etc.
        !             4:
        !             5: */
        !             6:
        !             7: #include "includes.h"
        !             8: RCSID("$OpenBSD: log-server.c,v 1.5 1999/10/17 20:39:11 dugsong 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: }