log.c

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