log.c

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