log.c

   1 /* $OpenBSD: log.c,v 1.34 2006/07/17 01:31:09 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 <syslog.h>
  41 #include <unistd.h>
  42 #if defined(HAVE_STRNVIS) && defined(HAVE_VIS_H)
  43 # include <vis.h>
  44 #endif
  45
  46 #include "log.h"
  47 #include "xmalloc.h"
  48
  49 static LogLevel log_level = SYSLOG_LEVEL_INFO;
  50 static int log_on_stderr = 1;
  51 static int log_facility = LOG_AUTH;
  52 static char *argv0;
  53
  54 extern char *__progname;
  55
  56 #define LOG_SYSLOG_VIS  (VIS_CSTYLE|VIS_NL|VIS_TAB|VIS_OCTAL)
  57 #define LOG_STDERR_VIS  (VIS_SAFE|VIS_OCTAL)
  58
  59 /* textual representation of log-facilities/levels */
  60
  61 static struct {
  62         const char *name;
  63         SyslogFacility val;
  64 } log_facilities[] = {
  65         { "DAEMON",     SYSLOG_FACILITY_DAEMON },
  66         { "USER",       SYSLOG_FACILITY_USER },
  67         { "AUTH",       SYSLOG_FACILITY_AUTH },
  68 #ifdef LOG_AUTHPRIV
  69         { "AUTHPRIV",   SYSLOG_FACILITY_AUTHPRIV },
  70 #endif
  71         { "LOCAL0",     SYSLOG_FACILITY_LOCAL0 },
  72         { "LOCAL1",     SYSLOG_FACILITY_LOCAL1 },
  73         { "LOCAL2",     SYSLOG_FACILITY_LOCAL2 },
  74         { "LOCAL3",     SYSLOG_FACILITY_LOCAL3 },
  75         { "LOCAL4",     SYSLOG_FACILITY_LOCAL4 },
  76         { "LOCAL5",     SYSLOG_FACILITY_LOCAL5 },
  77         { "LOCAL6",     SYSLOG_FACILITY_LOCAL6 },
  78         { "LOCAL7",     SYSLOG_FACILITY_LOCAL7 },
  79         { NULL,         SYSLOG_FACILITY_NOT_SET }
  80 };
  81
  82 static struct {
  83         const char *name;
  84         LogLevel val;
  85 } log_levels[] =
  86 {
  87         { "QUIET",      SYSLOG_LEVEL_QUIET },
  88         { "FATAL",      SYSLOG_LEVEL_FATAL },
  89         { "ERROR",      SYSLOG_LEVEL_ERROR },
  90         { "INFO",       SYSLOG_LEVEL_INFO },
  91         { "VERBOSE",    SYSLOG_LEVEL_VERBOSE },
  92         { "DEBUG",      SYSLOG_LEVEL_DEBUG1 },
  93         { "DEBUG1",     SYSLOG_LEVEL_DEBUG1 },
  94         { "DEBUG2",     SYSLOG_LEVEL_DEBUG2 },
  95         { "DEBUG3",     SYSLOG_LEVEL_DEBUG3 },
  96         { NULL,         SYSLOG_LEVEL_NOT_SET }
  97 };
  98
  99 SyslogFacility
 100 log_facility_number(char *name)
 101 {
 102         int i;
 103
 104         if (name != NULL)
 105                 for (i = 0; log_facilities[i].name; i++)
 106                         if (strcasecmp(log_facilities[i].name, name) == 0)
 107                                 return log_facilities[i].val;
 108         return SYSLOG_FACILITY_NOT_SET;
 109 }
 110
 111 LogLevel
 112 log_level_number(char *name)
 113 {
 114         int i;
 115
 116         if (name != NULL)
 117                 for (i = 0; log_levels[i].name; i++)
 118                         if (strcasecmp(log_levels[i].name, name) == 0)
 119                                 return log_levels[i].val;
 120         return SYSLOG_LEVEL_NOT_SET;
 121 }
 122
 123 /* Error messages that should be logged. */
 124
 125 void
 126 error(const char *fmt,...)
 127 {
 128         va_list args;
 129
 130         va_start(args, fmt);
 131         do_log(SYSLOG_LEVEL_ERROR, fmt, args);
 132         va_end(args);
 133 }
 134
 135 /* Log this message (information that usually should go to the log). */
 136
 137 void
 138 logit(const char *fmt,...)
 139 {
 140         va_list args;
 141
 142         va_start(args, fmt);
 143         do_log(SYSLOG_LEVEL_INFO, fmt, args);
 144         va_end(args);
 145 }
 146
 147 /* More detailed messages (information that does not need to go to the log). */
 148
 149 void
 150 verbose(const char *fmt,...)
 151 {
 152         va_list args;
 153
 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
 166         va_start(args, fmt);
 167         do_log(SYSLOG_LEVEL_DEBUG1, fmt, args);
 168         va_end(args);
 169 }
 170
 171 void
 172 debug2(const char *fmt,...)
 173 {
 174         va_list args;
 175
 176         va_start(args, fmt);
 177         do_log(SYSLOG_LEVEL_DEBUG2, fmt, args);
 178         va_end(args);
 179 }
 180
 181 void
 182 debug3(const char *fmt,...)
 183 {
 184         va_list args;
 185
 186         va_start(args, fmt);
 187         do_log(SYSLOG_LEVEL_DEBUG3, fmt, args);
 188         va_end(args);
 189 }
 190
 191 /*
 192  * Initialize the log.
 193  */
 194
 195 void
 196 log_init(char *av0, LogLevel level, SyslogFacility facility, int on_stderr)
 197 {
 198 #if defined(HAVE_OPENLOG_R) && defined(SYSLOG_DATA_INIT)
 199         struct syslog_data sdata = SYSLOG_DATA_INIT;
 200 #endif
 201
 202         argv0 = av0;
 203
 204         switch (level) {
 205         case SYSLOG_LEVEL_QUIET:
 206         case SYSLOG_LEVEL_FATAL:
 207         case SYSLOG_LEVEL_ERROR:
 208         case SYSLOG_LEVEL_INFO:
 209         case SYSLOG_LEVEL_VERBOSE:
 210         case SYSLOG_LEVEL_DEBUG1:
 211         case SYSLOG_LEVEL_DEBUG2:
 212         case SYSLOG_LEVEL_DEBUG3:
 213                 log_level = level;
 214                 break;
 215         default:
 216                 fprintf(stderr, "Unrecognized internal syslog level code %d\n",
 217                     (int) level);
 218                 exit(1);
 219         }
 220
 221         log_on_stderr = on_stderr;
 222         if (on_stderr)
 223                 return;
 224
 225         switch (facility) {
 226         case SYSLOG_FACILITY_DAEMON:
 227                 log_facility = LOG_DAEMON;
 228                 break;
 229         case SYSLOG_FACILITY_USER:
 230                 log_facility = LOG_USER;
 231                 break;
 232         case SYSLOG_FACILITY_AUTH:
 233                 log_facility = LOG_AUTH;
 234                 break;
 235 #ifdef LOG_AUTHPRIV
 236         case SYSLOG_FACILITY_AUTHPRIV:
 237                 log_facility = LOG_AUTHPRIV;
 238                 break;
 239 #endif
 240         case SYSLOG_FACILITY_LOCAL0:
 241                 log_facility = LOG_LOCAL0;
 242                 break;
 243         case SYSLOG_FACILITY_LOCAL1:
 244                 log_facility = LOG_LOCAL1;
 245                 break;
 246         case SYSLOG_FACILITY_LOCAL2:
 247                 log_facility = LOG_LOCAL2;
 248                 break;
 249         case SYSLOG_FACILITY_LOCAL3:
 250                 log_facility = LOG_LOCAL3;
 251                 break;
 252         case SYSLOG_FACILITY_LOCAL4:
 253                 log_facility = LOG_LOCAL4;
 254                 break;
 255         case SYSLOG_FACILITY_LOCAL5:
 256                 log_facility = LOG_LOCAL5;
 257                 break;
 258         case SYSLOG_FACILITY_LOCAL6:
 259                 log_facility = LOG_LOCAL6;
 260                 break;
 261         case SYSLOG_FACILITY_LOCAL7:
 262                 log_facility = LOG_LOCAL7;
 263                 break;
 264         default:
 265                 fprintf(stderr,
 266                     "Unrecognized internal syslog facility code %d\n",
 267                     (int) facility);
 268                 exit(1);
 269         }
 270
 271         /*
 272          * If an external library (eg libwrap) attempts to use syslog
 273          * immediately after reexec, syslog may be pointing to the wrong
 274          * facility, so we force an open/close of syslog here.
 275          */
 276 #if defined(HAVE_OPENLOG_R) && defined(SYSLOG_DATA_INIT)
 277         openlog_r(argv0 ? argv0 : __progname, LOG_PID, log_facility, &sdata);
 278         closelog_r(&sdata);
 279 #else
 280         openlog(argv0 ? argv0 : __progname, LOG_PID, log_facility);
 281         closelog();
 282 #endif
 283 }
 284
 285 #define MSGBUFSIZ 1024
 286
 287 void
 288 do_log(LogLevel level, const char *fmt, va_list args)
 289 {
 290 #if defined(HAVE_OPENLOG_R) && defined(SYSLOG_DATA_INIT)
 291         struct syslog_data sdata = SYSLOG_DATA_INIT;
 292 #endif
 293         char msgbuf[MSGBUFSIZ];
 294         char fmtbuf[MSGBUFSIZ];
 295         char *txt = NULL;
 296         int pri = LOG_INFO;
 297
 298         if (level > log_level)
 299                 return;
 300
 301         switch (level) {
 302         case SYSLOG_LEVEL_FATAL:
 303                 if (!log_on_stderr)
 304                         txt = "fatal";
 305                 pri = LOG_CRIT;
 306                 break;
 307         case SYSLOG_LEVEL_ERROR:
 308                 if (!log_on_stderr)
 309                         txt = "error";
 310                 pri = LOG_ERR;
 311                 break;
 312         case SYSLOG_LEVEL_INFO:
 313                 pri = LOG_INFO;
 314                 break;
 315         case SYSLOG_LEVEL_VERBOSE:
 316                 pri = LOG_INFO;
 317                 break;
 318         case SYSLOG_LEVEL_DEBUG1:
 319                 txt = "debug1";
 320                 pri = LOG_DEBUG;
 321                 break;
 322         case SYSLOG_LEVEL_DEBUG2:
 323                 txt = "debug2";
 324                 pri = LOG_DEBUG;
 325                 break;
 326         case SYSLOG_LEVEL_DEBUG3:
 327                 txt = "debug3";
 328                 pri = LOG_DEBUG;
 329                 break;
 330         default:
 331                 txt = "internal error";
 332                 pri = LOG_ERR;
 333                 break;
 334         }
 335         if (txt != NULL) {
 336                 snprintf(fmtbuf, sizeof(fmtbuf), "%s: %s", txt, fmt);
 337                 vsnprintf(msgbuf, sizeof(msgbuf), fmtbuf, args);
 338         } else {
 339                 vsnprintf(msgbuf, sizeof(msgbuf), fmt, args);
 340         }
 341         strnvis(fmtbuf, msgbuf, sizeof(fmtbuf),
 342             log_on_stderr ? LOG_STDERR_VIS : LOG_SYSLOG_VIS);
 343         if (log_on_stderr) {
 344                 snprintf(msgbuf, sizeof msgbuf, "%s\r\n", fmtbuf);
 345                 write(STDERR_FILENO, msgbuf, strlen(msgbuf));
 346         } else {
 347 #if defined(HAVE_OPENLOG_R) && defined(SYSLOG_DATA_INIT)
 348                 openlog_r(argv0 ? argv0 : __progname, LOG_PID, log_facility, &sdata);
 349                 syslog_r(pri, &sdata, "%.500s", fmtbuf);
 350                 closelog_r(&sdata);
 351 #else
 352                 openlog(argv0 ? argv0 : __progname, LOG_PID, log_facility);
 353                 syslog(pri, "%.500s", fmtbuf);
 354                 closelog();
 355 #endif
 356         }
 357 }