log.c

   1 /*
   2  * Author: Tatu Ylonen <ylo@cs.hut.fi>
   3  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   4  *                    All rights reserved
   5  *
   6  * As far as I am concerned, the code I have written for this software
   7  * can be used freely for any purpose.  Any derived versions of this
   8  * software must be clearly marked as such, and if the derived work is
   9  * incompatible with the protocol description in the RFC file, it must be
  10  * called by a name other than "ssh" or "Secure Shell".
  11  */
  12 /*
  13  * Copyright (c) 2000 Markus Friedl.  All rights reserved.
  14  *
  15  * Redistribution and use in source and binary forms, with or without
  16  * modification, are permitted provided that the following conditions
  17  * are met:
  18  * 1. Redistributions of source code must retain the above copyright
  19  *    notice, this list of conditions and the following disclaimer.
  20  * 2. Redistributions in binary form must reproduce the above copyright
  21  *    notice, this list of conditions and the following disclaimer in the
  22  *    documentation and/or other materials provided with the distribution.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  25  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  26  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  27  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  28  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  29  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  30  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  31  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  32  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  33  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 #include "includes.h"
  37 RCSID("$OpenBSD: log.c,v 1.21 2002/02/04 12:15:25 markus Exp $");
  38
  39 #include "log.h"
  40 #include "xmalloc.h"
  41
  42 #include <syslog.h>
  43
  44 static LogLevel log_level = SYSLOG_LEVEL_INFO;
  45 static int log_on_stderr = 1;
  46 static int log_facility = LOG_AUTH;
  47 static char *argv0;
  48
  49 extern char *__progname;
  50
  51 /* textual representation of log-facilities/levels */
  52
  53 static struct {
  54         const char *name;
  55         SyslogFacility val;
  56 } log_facilities[] = {
  57         { "DAEMON",     SYSLOG_FACILITY_DAEMON },
  58         { "USER",       SYSLOG_FACILITY_USER },
  59         { "AUTH",       SYSLOG_FACILITY_AUTH },
  60 #ifdef LOG_AUTHPRIV
  61         { "AUTHPRIV",   SYSLOG_FACILITY_AUTHPRIV },
  62 #endif
  63         { "LOCAL0",     SYSLOG_FACILITY_LOCAL0 },
  64         { "LOCAL1",     SYSLOG_FACILITY_LOCAL1 },
  65         { "LOCAL2",     SYSLOG_FACILITY_LOCAL2 },
  66         { "LOCAL3",     SYSLOG_FACILITY_LOCAL3 },
  67         { "LOCAL4",     SYSLOG_FACILITY_LOCAL4 },
  68         { "LOCAL5",     SYSLOG_FACILITY_LOCAL5 },
  69         { "LOCAL6",     SYSLOG_FACILITY_LOCAL6 },
  70         { "LOCAL7",     SYSLOG_FACILITY_LOCAL7 },
  71         { NULL,         SYSLOG_FACILITY_NOT_SET }
  72 };
  73
  74 static struct {
  75         const char *name;
  76         LogLevel val;
  77 } log_levels[] =
  78 {
  79         { "QUIET",      SYSLOG_LEVEL_QUIET },
  80         { "FATAL",      SYSLOG_LEVEL_FATAL },
  81         { "ERROR",      SYSLOG_LEVEL_ERROR },
  82         { "INFO",       SYSLOG_LEVEL_INFO },
  83         { "VERBOSE",    SYSLOG_LEVEL_VERBOSE },
  84         { "DEBUG",      SYSLOG_LEVEL_DEBUG1 },
  85         { "DEBUG1",     SYSLOG_LEVEL_DEBUG1 },
  86         { "DEBUG2",     SYSLOG_LEVEL_DEBUG2 },
  87         { "DEBUG3",     SYSLOG_LEVEL_DEBUG3 },
  88         { NULL,         SYSLOG_LEVEL_NOT_SET }
  89 };
  90
  91 static void      do_log(LogLevel level, const char *fmt, va_list args);
  92
  93 SyslogFacility
  94 log_facility_number(char *name)
  95 {
  96         int i;
  97         if (name != NULL)
  98                 for (i = 0; log_facilities[i].name; i++)
  99                         if (strcasecmp(log_facilities[i].name, name) == 0)
 100                                 return log_facilities[i].val;
 101         return SYSLOG_FACILITY_NOT_SET;
 102 }
 103
 104 LogLevel
 105 log_level_number(char *name)
 106 {
 107         int i;
 108         if (name != NULL)
 109                 for (i = 0; log_levels[i].name; i++)
 110                         if (strcasecmp(log_levels[i].name, name) == 0)
 111                                 return log_levels[i].val;
 112         return SYSLOG_LEVEL_NOT_SET;
 113 }
 114 /* Fatal messages.  This function never returns. */
 115
 116 void
 117 fatal(const char *fmt,...)
 118 {
 119         va_list args;
 120         va_start(args, fmt);
 121         do_log(SYSLOG_LEVEL_FATAL, fmt, args);
 122         va_end(args);
 123         fatal_cleanup();
 124 }
 125
 126 /* Error messages that should be logged. */
 127
 128 void
 129 error(const char *fmt,...)
 130 {
 131         va_list args;
 132         va_start(args, fmt);
 133         do_log(SYSLOG_LEVEL_ERROR, fmt, args);
 134         va_end(args);
 135 }
 136
 137 /* Log this message (information that usually should go to the log). */
 138
 139 void
 140 log(const char *fmt,...)
 141 {
 142         va_list args;
 143         va_start(args, fmt);
 144         do_log(SYSLOG_LEVEL_INFO, fmt, args);
 145         va_end(args);
 146 }
 147
 148 /* More detailed messages (information that does not need to go to the log). */
 149
 150 void
 151 verbose(const char *fmt,...)
 152 {
 153         va_list args;
 154         va_start(args, fmt);
 155         do_log(SYSLOG_LEVEL_VERBOSE, fmt, args);
 156         va_end(args);
 157 }
 158
 159 /* Debugging messages that should not be logged during normal operation. */
 160
 161 void
 162 debug(const char *fmt,...)
 163 {
 164         va_list args;
 165         va_start(args, fmt);
 166         do_log(SYSLOG_LEVEL_DEBUG1, fmt, args);
 167         va_end(args);
 168 }
 169
 170 void
 171 debug2(const char *fmt,...)
 172 {
 173         va_list args;
 174         va_start(args, fmt);
 175         do_log(SYSLOG_LEVEL_DEBUG2, fmt, args);
 176         va_end(args);
 177 }
 178
 179 void
 180 debug3(const char *fmt,...)
 181 {
 182         va_list args;
 183         va_start(args, fmt);
 184         do_log(SYSLOG_LEVEL_DEBUG3, fmt, args);
 185         va_end(args);
 186 }
 187
 188 /* Fatal cleanup */
 189
 190 struct fatal_cleanup {
 191         struct fatal_cleanup *next;
 192         void (*proc) (void *);
 193         void *context;
 194 };
 195
 196 static struct fatal_cleanup *fatal_cleanups = NULL;
 197
 198 /* Registers a cleanup function to be called by fatal() before exiting. */
 199
 200 void
 201 fatal_add_cleanup(void (*proc) (void *), void *context)
 202 {
 203         struct fatal_cleanup *cu;
 204
 205         cu = xmalloc(sizeof(*cu));
 206         cu->proc = proc;
 207         cu->context = context;
 208         cu->next = fatal_cleanups;
 209         fatal_cleanups = cu;
 210 }
 211
 212 /* Removes a cleanup frunction to be called at fatal(). */
 213
 214 void
 215 fatal_remove_cleanup(void (*proc) (void *context), void *context)
 216 {
 217         struct fatal_cleanup **cup, *cu;
 218
 219         for (cup = &fatal_cleanups; *cup; cup = &cu->next) {
 220                 cu = *cup;
 221                 if (cu->proc == proc && cu->context == context) {
 222                         *cup = cu->next;
 223                         xfree(cu);
 224                         return;
 225                 }
 226         }
 227         fatal("fatal_remove_cleanup: no such cleanup function: 0x%lx 0x%lx",
 228             (u_long) proc, (u_long) context);
 229 }
 230
 231 /* Cleanup and exit */
 232 void
 233 fatal_cleanup(void)
 234 {
 235         struct fatal_cleanup *cu, *next_cu;
 236         static int called = 0;
 237
 238         if (called)
 239                 exit(255);
 240         called = 1;
 241         /* Call cleanup functions. */
 242         for (cu = fatal_cleanups; cu; cu = next_cu) {
 243                 next_cu = cu->next;
 244                 debug("Calling cleanup 0x%lx(0x%lx)",
 245                     (u_long) cu->proc, (u_long) cu->context);
 246                 (*cu->proc) (cu->context);
 247         }
 248         exit(255);
 249 }
 250
 251
 252 /*
 253  * Initialize the log.
 254  */
 255
 256 void
 257 log_init(char *av0, LogLevel level, SyslogFacility facility, int on_stderr)
 258 {
 259         argv0 = av0;
 260
 261         switch (level) {
 262         case SYSLOG_LEVEL_QUIET:
 263         case SYSLOG_LEVEL_FATAL:
 264         case SYSLOG_LEVEL_ERROR:
 265         case SYSLOG_LEVEL_INFO:
 266         case SYSLOG_LEVEL_VERBOSE:
 267         case SYSLOG_LEVEL_DEBUG1:
 268         case SYSLOG_LEVEL_DEBUG2:
 269         case SYSLOG_LEVEL_DEBUG3:
 270                 log_level = level;
 271                 break;
 272         default:
 273                 fprintf(stderr, "Unrecognized internal syslog level code %d\n",
 274                     (int) level);
 275                 exit(1);
 276         }
 277
 278         log_on_stderr = on_stderr;
 279         if (on_stderr)
 280                 return;
 281
 282         switch (facility) {
 283         case SYSLOG_FACILITY_DAEMON:
 284                 log_facility = LOG_DAEMON;
 285                 break;
 286         case SYSLOG_FACILITY_USER:
 287                 log_facility = LOG_USER;
 288                 break;
 289         case SYSLOG_FACILITY_AUTH:
 290                 log_facility = LOG_AUTH;
 291                 break;
 292 #ifdef LOG_AUTHPRIV
 293         case SYSLOG_FACILITY_AUTHPRIV:
 294                 log_facility = LOG_AUTHPRIV;
 295                 break;
 296 #endif
 297         case SYSLOG_FACILITY_LOCAL0:
 298                 log_facility = LOG_LOCAL0;
 299                 break;
 300         case SYSLOG_FACILITY_LOCAL1:
 301                 log_facility = LOG_LOCAL1;
 302                 break;
 303         case SYSLOG_FACILITY_LOCAL2:
 304                 log_facility = LOG_LOCAL2;
 305                 break;
 306         case SYSLOG_FACILITY_LOCAL3:
 307                 log_facility = LOG_LOCAL3;
 308                 break;
 309         case SYSLOG_FACILITY_LOCAL4:
 310                 log_facility = LOG_LOCAL4;
 311                 break;
 312         case SYSLOG_FACILITY_LOCAL5:
 313                 log_facility = LOG_LOCAL5;
 314                 break;
 315         case SYSLOG_FACILITY_LOCAL6:
 316                 log_facility = LOG_LOCAL6;
 317                 break;
 318         case SYSLOG_FACILITY_LOCAL7:
 319                 log_facility = LOG_LOCAL7;
 320                 break;
 321         default:
 322                 fprintf(stderr,
 323                     "Unrecognized internal syslog facility code %d\n",
 324                     (int) facility);
 325                 exit(1);
 326         }
 327 }
 328
 329 #define MSGBUFSIZ 1024
 330
 331 static void
 332 do_log(LogLevel level, const char *fmt, va_list args)
 333 {
 334         char msgbuf[MSGBUFSIZ];
 335         char fmtbuf[MSGBUFSIZ];
 336         char *txt = NULL;
 337         int pri = LOG_INFO;
 338
 339         if (level > log_level)
 340                 return;
 341
 342         switch (level) {
 343         case SYSLOG_LEVEL_FATAL:
 344                 if (!log_on_stderr)
 345                         txt = "fatal";
 346                 pri = LOG_CRIT;
 347                 break;
 348         case SYSLOG_LEVEL_ERROR:
 349                 if (!log_on_stderr)
 350                         txt = "error";
 351                 pri = LOG_ERR;
 352                 break;
 353         case SYSLOG_LEVEL_INFO:
 354                 pri = LOG_INFO;
 355                 break;
 356         case SYSLOG_LEVEL_VERBOSE:
 357                 pri = LOG_INFO;
 358                 break;
 359         case SYSLOG_LEVEL_DEBUG1:
 360                 txt = "debug1";
 361                 pri = LOG_DEBUG;
 362                 break;
 363         case SYSLOG_LEVEL_DEBUG2:
 364                 txt = "debug2";
 365                 pri = LOG_DEBUG;
 366                 break;
 367         case SYSLOG_LEVEL_DEBUG3:
 368                 txt = "debug3";
 369                 pri = LOG_DEBUG;
 370                 break;
 371         default:
 372                 txt = "internal error";
 373                 pri = LOG_ERR;
 374                 break;
 375         }
 376         if (txt != NULL) {
 377                 snprintf(fmtbuf, sizeof(fmtbuf), "%s: %s", txt, fmt);
 378                 vsnprintf(msgbuf, sizeof(msgbuf), fmtbuf, args);
 379         } else {
 380                 vsnprintf(msgbuf, sizeof(msgbuf), fmt, args);
 381         }
 382         if (log_on_stderr) {
 383                 fprintf(stderr, "%s\r\n", msgbuf);
 384         } else {
 385                 openlog(argv0 ? argv0 : __progname, LOG_PID, log_facility);
 386                 syslog(pri, "%.500s", msgbuf);
 387                 closelog();
 388         }
 389 }