misc/syslog.c

   1 /*
   2  * Copyright (c) 1983, 1988, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 4. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #if defined(LIBC_SCCS) && !defined(lint)
  31 static char sccsid[] = "@(#)syslog.c    8.4 (Berkeley) 3/18/94";
  32 #endif /* LIBC_SCCS and not lint */
  33
  34 #include <libio/libioP.h>
  35 #include <paths.h>
  36 #include <stdarg.h>
  37 #include <stdlib.h>
  38 #include <stdio.h>
  39 #include <stdio_ext.h>
  40 #include <sys/socket.h>
  41 #include <sys/uio.h>
  42 #include <sys/un.h>
  43 #include <syslog.h>
  44
  45 static int LogType = SOCK_DGRAM;        /* type of socket connection */
  46 static int LogFile = -1;                /* fd for log */
  47 static bool connected;                  /* have done connect */
  48 static int LogStat;                     /* status bits, set by openlog() */
  49 static const char *LogTag;              /* string to tag the entry with */
  50 static int LogFacility = LOG_USER;      /* default facility code */
  51 static int LogMask = 0xff;              /* mask of priorities to be logged */
  52 extern char *__progname;                /* Program name, from crt0. */
  53
  54 /* Define the lock.  */
  55 __libc_lock_define_initialized (static, syslog_lock)
  56 static void openlog_internal (const char *, int, int);
  57 static void closelog_internal (void);
  58
  59 struct cleanup_arg
  60 {
  61   void *buf;
  62   struct sigaction *oldaction;
  63 };
  64
  65 static void
  66 cancel_handler (void *ptr)
  67 {
  68   /* Restore the old signal handler.  */
  69   struct cleanup_arg *clarg = (struct cleanup_arg *) ptr;
  70
  71   if (clarg != NULL)
  72     /* Free the memstream buffer,  */
  73     free (clarg->buf);
  74
  75   /* Free the lock.  */
  76   __libc_lock_unlock (syslog_lock);
  77 }
  78
  79
  80 /*
  81  * syslog, vsyslog --
  82  *      print message on log file; output is intended for syslogd(8).
  83  */
  84 void
  85 __syslog (int pri, const char *fmt, ...)
  86 {
  87   va_list ap;
  88
  89   va_start (ap, fmt);
  90   __vsyslog_internal (pri, fmt, ap, 0);
  91   va_end (ap);
  92 }
  93 ldbl_hidden_def (__syslog, syslog)
  94 ldbl_strong_alias (__syslog, syslog)
  95
  96 void
  97 __vsyslog (int pri, const char *fmt, va_list ap)
  98 {
  99   __vsyslog_internal (pri, fmt, ap, 0);
 100 }
 101 ldbl_weak_alias (__vsyslog, vsyslog)
 102
 103 void
 104 __syslog_chk (int pri, int flag, const char *fmt, ...)
 105 {
 106   va_list ap;
 107
 108   va_start (ap, fmt);
 109   __vsyslog_internal (pri, fmt, ap, (flag > 0) ? PRINTF_FORTIFY : 0);
 110   va_end (ap);
 111 }
 112
 113 void
 114 __vsyslog_chk (int pri, int flag, const char *fmt, va_list ap)
 115 {
 116   __vsyslog_internal (pri, fmt, ap, (flag > 0) ? PRINTF_FORTIFY : 0);
 117 }
 118
 119 void
 120 __vsyslog_internal (int pri, const char *fmt, va_list ap,
 121                     unsigned int mode_flags)
 122 {
 123   /* Try to use a static buffer as an optimization.  */
 124   char bufs[1024];
 125   char *buf = NULL;
 126   size_t bufsize = 0;
 127   int msgoff;
 128   int saved_errno = errno;
 129
 130 #define INTERNALLOG LOG_ERR|LOG_CONS|LOG_PERROR|LOG_PID
 131   /* Check for invalid bits. */
 132   if (pri & ~(LOG_PRIMASK | LOG_FACMASK))
 133     {
 134       syslog (INTERNALLOG, "syslog: unknown facility/priority: %x", pri);
 135       pri &= LOG_PRIMASK | LOG_FACMASK;
 136     }
 137
 138   /* Prepare for multiple users.  We have to take care: most syscalls we are
 139      using are cancellation points.  */
 140   struct cleanup_arg clarg = { NULL, NULL };
 141   __libc_cleanup_push (cancel_handler, &clarg);
 142   __libc_lock_lock (syslog_lock);
 143
 144   /* Check priority against setlogmask values. */
 145   if ((LOG_MASK (LOG_PRI (pri)) & LogMask) == 0)
 146     goto out;
 147
 148   /* Set default facility if none specified. */
 149   if ((pri & LOG_FACMASK) == 0)
 150     pri |= LogFacility;
 151
 152   pid_t pid = LogStat & LOG_PID ? __getpid () : 0;
 153
 154   /* "%b %e %H:%M:%S "  */
 155   char timestamp[sizeof "MMM DD hh:mm:ss "];
 156   __time64_t now = time64_now ();
 157   struct tm now_tm;
 158   struct tm *now_tmp = __localtime64_r (&now, &now_tm);
 159   bool has_ts = now_tmp != NULL;
 160
 161   /* In the unlikely case of localtime_r failure (tm_year out of int range)
 162      skip the hostname so the message is handled as valid PRI but without
 163      TIMESTAMP or invalid TIMESTAMP (which should force the relay to add the
 164      timestamp itself).  */
 165   if (has_ts)
 166     __strftime_l (timestamp, sizeof timestamp, "%h %e %T ", now_tmp,
 167                   _nl_C_locobj_ptr);
 168
 169 #define SYSLOG_HEADER(__pri, __timestamp, __msgoff, pid) \
 170   "<%d>%s%n%s%s%.0d%s: ",                                \
 171   __pri, __timestamp, __msgoff,                          \
 172   LogTag == NULL ? __progname : LogTag,                  \
 173   "[" + (pid == 0), pid, "]" + (pid == 0)
 174
 175 #define SYSLOG_HEADER_WITHOUT_TS(__pri, __msgoff)        \
 176   "<%d>: %n", __pri, __msgoff
 177
 178   int l;
 179   if (has_ts)
 180     l = __snprintf (bufs, sizeof bufs,
 181                     SYSLOG_HEADER (pri, timestamp, &msgoff, pid));
 182   else
 183     l = __snprintf (bufs, sizeof bufs,
 184                     SYSLOG_HEADER_WITHOUT_TS (pri, &msgoff));
 185   if (0 <= l && l < sizeof bufs)
 186     {
 187       va_list apc;
 188       va_copy (apc, ap);
 189
 190       /* Restore errno for %m format.  */
 191       __set_errno (saved_errno);
 192
 193       int vl = __vsnprintf_internal (bufs + l, sizeof bufs - l, fmt, apc,
 194                                      mode_flags);
 195       if (0 <= vl && vl < sizeof bufs - l)
 196         buf = bufs;
 197       bufsize = l + vl;
 198
 199       va_end (apc);
 200     }
 201
 202   if (buf == NULL)
 203     {
 204       buf = malloc ((bufsize + 1) * sizeof (char));
 205       if (buf != NULL)
 206         {
 207           /* Tell the cancellation handler to free this buffer.  */
 208           clarg.buf = buf;
 209
 210           if (has_ts)
 211             __snprintf (buf, l + 1,
 212                         SYSLOG_HEADER (pri, timestamp, &msgoff, pid));
 213           else
 214             __snprintf (buf, l + 1,
 215                         SYSLOG_HEADER_WITHOUT_TS (pri, &msgoff));
 216
 217           va_list apc;
 218           va_copy (apc, ap);
 219           __vsnprintf_internal (buf + l, bufsize - l + 1, fmt, apc,
 220                                 mode_flags);
 221           va_end (apc);
 222         }
 223       else
 224         {
 225           /* Nothing much to do but emit an error message.  */
 226           bufsize = __snprintf (bufs, sizeof bufs,
 227                                 "out of memory[%d]", __getpid ());
 228           buf = bufs;
 229         }
 230     }
 231
 232   /* Output to stderr if requested. */
 233   if (LogStat & LOG_PERROR)
 234     __dprintf (STDERR_FILENO, "%s%s", buf + msgoff,
 235                "\n" + (buf[bufsize - 1] == '\n'));
 236
 237   /* Get connected, output the message to the local logger.  */
 238   if (!connected)
 239     openlog_internal (NULL, LogStat | LOG_NDELAY, LogFacility);
 240
 241   /* If we have a SOCK_STREAM connection, also send ASCII NUL as a record
 242      terminator.  */
 243   if (LogType == SOCK_STREAM)
 244     ++bufsize;
 245
 246   if (!connected || __send (LogFile, buf, bufsize, MSG_NOSIGNAL) < 0)
 247     {
 248       if (connected)
 249         {
 250           /* Try to reopen the syslog connection.  Maybe it went down.  */
 251           closelog_internal ();
 252           openlog_internal (NULL, LogStat | LOG_NDELAY, LogFacility);
 253         }
 254
 255       if (!connected || __send (LogFile, buf, bufsize, MSG_NOSIGNAL) < 0)
 256         {
 257           closelog_internal (); /* attempt re-open next time */
 258           /*
 259            * Output the message to the console; don't worry
 260            * about blocking, if console blocks everything will.
 261            * Make sure the error reported is the one from the
 262            * syslogd failure.
 263            */
 264           int fd;
 265           if (LogStat & LOG_CONS &&
 266               (fd = __open (_PATH_CONSOLE, O_WRONLY | O_NOCTTY
 267                             | O_CLOEXEC, 0)) >= 0)
 268             {
 269               __dprintf (fd, "%s\r\n", buf + msgoff);
 270               __close (fd);
 271             }
 272         }
 273     }
 274
 275 out:
 276   /* End of critical section.  */
 277   __libc_cleanup_pop (0);
 278   __libc_lock_unlock (syslog_lock);
 279
 280   if (buf != bufs)
 281     free (buf);
 282 }
 283
 284 /* AF_UNIX address of local logger  */
 285 static const struct sockaddr_un SyslogAddr =
 286   {
 287     .sun_family = AF_UNIX,
 288     .sun_path = _PATH_LOG
 289   };
 290
 291 static void
 292 openlog_internal (const char *ident, int logstat, int logfac)
 293 {
 294   if (ident != NULL)
 295     LogTag = ident;
 296   LogStat = logstat;
 297   if ((logfac & ~LOG_FACMASK) == 0)
 298     LogFacility = logfac;
 299
 300   int retry = 0;
 301   while (retry < 2)
 302     {
 303       if (LogFile == -1)
 304         {
 305           if (LogStat & LOG_NDELAY)
 306             {
 307               LogFile = __socket (AF_UNIX, LogType | SOCK_CLOEXEC, 0);
 308               if (LogFile == -1)
 309                 return;
 310             }
 311         }
 312       if (LogFile != -1 && !connected)
 313         {
 314           int old_errno = errno;
 315           if (__connect (LogFile, &SyslogAddr, sizeof (SyslogAddr)) == -1)
 316             {
 317               int saved_errno = errno;
 318               int fd = LogFile;
 319               LogFile = -1;
 320               __close (fd);
 321               __set_errno (old_errno);
 322               if (saved_errno == EPROTOTYPE)
 323                 {
 324                   /* retry with the other type: */
 325                   LogType = LogType == SOCK_DGRAM ? SOCK_STREAM : SOCK_DGRAM;
 326                   ++retry;
 327                   continue;
 328                 }
 329             }
 330           else
 331             connected = true;
 332         }
 333       break;
 334     }
 335 }
 336
 337 void
 338 openlog (const char *ident, int logstat, int logfac)
 339 {
 340   /* Protect against multiple users and cancellation.  */
 341   __libc_cleanup_push (cancel_handler, NULL);
 342   __libc_lock_lock (syslog_lock);
 343
 344   openlog_internal (ident, logstat, logfac);
 345
 346   __libc_cleanup_pop (1);
 347 }
 348
 349 static void
 350 closelog_internal (void)
 351 {
 352   if (!connected)
 353     return;
 354
 355   __close (LogFile);
 356   LogFile = -1;
 357   connected = false;
 358 }
 359
 360 void
 361 closelog (void)
 362 {
 363   /* Protect against multiple users and cancellation.  */
 364   __libc_cleanup_push (cancel_handler, NULL);
 365   __libc_lock_lock (syslog_lock);
 366
 367   closelog_internal ();
 368   LogTag = NULL;
 369   LogType = SOCK_DGRAM; /* this is the default */
 370
 371   /* Free the lock.  */
 372   __libc_cleanup_pop (1);
 373 }
 374
 375 /* setlogmask -- set the log mask level */
 376 int
 377 setlogmask (int pmask)
 378 {
 379   int omask;
 380
 381   /* Protect against multiple users.  */
 382   __libc_lock_lock (syslog_lock);
 383
 384   omask = LogMask;
 385   if (pmask != 0)
 386     LogMask = pmask;
 387
 388   __libc_lock_unlock (syslog_lock);
 389
 390   return (omask);
 391 }