l4/pkg/uclibc/lib/contrib/uclibc/libc/misc/syslog/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  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 /*
  35  * SYSLOG -- print message on log file
  36  *
  37  * This routine looks a lot like printf, except that it outputs to the
  38  * log file instead of the standard output.  Also:
  39  *      adds a timestamp,
  40  *      prints the module name in front of the message,
  41  *      has some other formatting types (or will sometime),
  42  *      adds a newline on the end of the message.
  43  *
  44  * The output of this routine is intended to be read by syslogd(8).
  45  *
  46  * Author: Eric Allman
  47  * Modified to use UNIX domain IPC by Ralph Campbell
  48  * Patched March 12, 1996 by A. Ian Vogelesang <vogelesang@hdshq.com>
  49  *  - to correct the handling of message & format string truncation,
  50  *  - to visibly tag truncated records to facilitate
  51  *    investigation of such Bad Things with grep, and,
  52  *  - to correct the handling of case where "write"
  53  *    returns after writing only part of the message.
  54  * Rewritten by Martin Mares <mj@atrey.karlin.mff.cuni.cz> on May 14, 1997
  55  *  - better buffer overrun checks.
  56  *  - special handling of "%m" removed as we use GNU sprintf which handles
  57  *    it automatically.
  58  *  - Major code cleanup.
  59  */
  60
  61 #include <sys/types.h>
  62 #include <sys/socket.h>
  63 #include <sys/file.h>
  64 #include <sys/signal.h>
  65 #include <sys/syslog.h>
  66
  67 #include <sys/uio.h>
  68 #include <sys/wait.h>
  69 #include <netdb.h>
  70 #include <string.h>
  71 #include <time.h>
  72 #include <unistd.h>
  73 #include <errno.h>
  74 #include <stdarg.h>
  75 #include <paths.h>
  76 #include <stdio.h>
  77 #include <ctype.h>
  78 #include <signal.h>
  79
  80
  81 #include <bits/uClibc_mutex.h>
  82
  83 __UCLIBC_MUTEX_STATIC(mylock, PTHREAD_MUTEX_INITIALIZER);
  84
  85
  86 /* !glibc_compat: glibc uses argv[0] by default
  87  * (default: if there was no openlog or if openlog passed NULL),
  88  * not string "syslog"
  89  */
  90 static const char *LogTag = "syslog";   /* string to tag the entry with */
  91 static int       LogFile = -1;          /* fd for log */
  92 static smalluint connected;             /* have done connect */
  93 /* all bits in option argument for openlog fit in 8 bits */
  94 static smalluint LogStat = 0;           /* status bits, set by openlog */
  95 /* default facility code if openlog is not called */
  96 /* (this fits in 8 bits even without >> 3 shift, but playing extra safe) */
  97 static smalluint LogFacility = LOG_USER >> 3;
  98 /* bits mask of priorities to be logged (eight prios - 8 bits is enough) */
  99 static smalluint LogMask = 0xff;
 100 /* AF_UNIX address of local logger (we use struct sockaddr
 101  * instead of struct sockaddr_un since "/dev/log" is small enough) */
 102 static const struct sockaddr SyslogAddr = {
 103         .sa_family = AF_UNIX, /* sa_family_t (usually a short) */
 104         .sa_data = _PATH_LOG  /* char [14] */
 105 };
 106
 107 static void
 108 closelog_intern(int sig)
 109 {
 110         /* mylock must be held by the caller */
 111         if (LogFile != -1) {
 112                 (void) close(LogFile);
 113         }
 114         LogFile = -1;
 115         connected = 0;
 116         if (sig == 0) { /* called from closelog()? - reset to defaults */
 117                 LogStat = 0;
 118                 LogTag = "syslog";
 119                 LogFacility = LOG_USER >> 3;
 120                 LogMask = 0xff;
 121         }
 122 }
 123
 124 static void
 125 openlog_intern(const char *ident, int logstat, int logfac)
 126 {
 127         int fd;
 128         int logType = SOCK_DGRAM;
 129
 130         if (ident != NULL)
 131                 LogTag = ident;
 132         LogStat = logstat;
 133         /* (we were checking also for logfac != 0, but it breaks
 134          * openlog(xx, LOG_KERN) since LOG_KERN == 0) */
 135         if ((logfac & ~LOG_FACMASK) == 0) /* if we don't have invalid bits */
 136                 LogFacility = (unsigned)logfac >> 3;
 137
 138         fd = LogFile;
 139         if (fd == -1) {
 140  retry:
 141                 if (logstat & LOG_NDELAY) {
 142                         LogFile = fd = socket(AF_UNIX, logType, 0);
 143                         if (fd == -1) {
 144                                 return;
 145                         }
 146                         fcntl(fd, F_SETFD, FD_CLOEXEC);
 147                         /* We don't want to block if e.g. syslogd is SIGSTOPed */
 148                         fcntl(fd, F_SETFL, O_NONBLOCK | fcntl(fd, F_GETFL));
 149                 }
 150         }
 151
 152         if (fd != -1 && !connected) {
 153                 if (connect(fd, &SyslogAddr, sizeof(SyslogAddr)) != -1) {
 154                         connected = 1;
 155                 } else {
 156                         if (fd != -1) {
 157                                 close(fd);
 158                                 LogFile = fd = -1;
 159                         }
 160                         if (logType == SOCK_DGRAM) {
 161                                 logType = SOCK_STREAM;
 162                                 goto retry;
 163                         }
 164                 }
 165         }
 166 }
 167
 168 /*
 169  * OPENLOG -- open system log
 170  */
 171 void
 172 openlog(const char *ident, int logstat, int logfac)
 173 {
 174         __UCLIBC_MUTEX_LOCK(mylock);
 175         openlog_intern(ident, logstat, logfac);
 176         __UCLIBC_MUTEX_UNLOCK(mylock);
 177 }
 178
 179 /*
 180  * syslog, vsyslog --
 181  *     print message on log file; output is intended for syslogd(8).
 182  */
 183 static
 184 #ifndef __USE_BSD
 185 __always_inline
 186 #endif
 187 void
 188 __vsyslog(int pri, const char *fmt, va_list ap)
 189 {
 190         register char *p;
 191         char *last_chr, *head_end, *end, *stdp;
 192         time_t now;
 193         int fd, saved_errno;
 194         int rc;
 195         char tbuf[1024]; /* syslogd is unable to handle longer messages */
 196
 197         /* Just throw out this message if pri has bad bits. */
 198         if ((pri & ~(LOG_PRIMASK|LOG_FACMASK)) != 0)
 199                 return;
 200
 201         saved_errno = errno;
 202
 203         __UCLIBC_MUTEX_LOCK(mylock);
 204
 205         /* See if we should just throw out this message according to LogMask. */
 206         if ((LogMask & LOG_MASK(LOG_PRI(pri))) == 0)
 207                 goto getout;
 208         if (LogFile < 0 || !connected)
 209                 openlog_intern(NULL, LogStat | LOG_NDELAY, (int)LogFacility << 3);
 210
 211         /* Set default facility if none specified. */
 212         if ((pri & LOG_FACMASK) == 0)
 213                 pri |= ((int)LogFacility << 3);
 214
 215         /* Build the message. We know the starting part of the message can take
 216          * no longer than 64 characters plus length of the LogTag. So it's
 217          * safe to test only LogTag and use normal sprintf everywhere else.
 218          */
 219         (void)time(&now);
 220         stdp = p = tbuf + sprintf(tbuf, "<%d>%.15s ", pri, ctime(&now) + 4);
 221         /*if (LogTag) - always true */ {
 222                 if (strlen(LogTag) < sizeof(tbuf) - 64)
 223                         p += sprintf(p, "%s", LogTag);
 224                 else
 225                         p += sprintf(p, "<BUFFER OVERRUN ATTEMPT>");
 226         }
 227         if (LogStat & LOG_PID)
 228                 p += sprintf(p, "[%d]", getpid());
 229         /*if (LogTag) - always true */ {
 230                 *p++ = ':';
 231                 *p++ = ' ';
 232         }
 233         head_end = p;
 234
 235         /* We format the rest of the message. If the buffer becomes full, we mark
 236          * the message as truncated. Note that we require at least 2 free bytes
 237          * in the buffer as we might want to add "\r\n" there.
 238          */
 239
 240         end = tbuf + sizeof(tbuf) - 1;
 241         __set_errno(saved_errno);
 242         p += vsnprintf(p, end - p, fmt, ap);
 243         if (p >= end || p < head_end) { /* Returned -1 in case of error... */
 244                 static const char truncate_msg[12] = "[truncated] "; /* no NUL! */
 245                 memmove(head_end + sizeof(truncate_msg), head_end,
 246                                 end - head_end - sizeof(truncate_msg));
 247                 memcpy(head_end, truncate_msg, sizeof(truncate_msg));
 248                 if (p < head_end) {
 249                         while (p < end && *p) {
 250                                 p++;
 251                         }
 252                 }
 253                 else {
 254                         p = end - 1;
 255                 }
 256
 257         }
 258         last_chr = p;
 259
 260         /* Output to stderr if requested. */
 261         if (LogStat & LOG_PERROR) {
 262                 *last_chr = '\n';
 263                 (void)write(STDERR_FILENO, stdp, last_chr - stdp + 1);
 264         }
 265
 266         /* Output the message to the local logger using NUL as a message delimiter. */
 267         p = tbuf;
 268         *last_chr = '\0';
 269         if (LogFile >= 0) {
 270                 do {
 271                         /* can't just use write, it can result in SIGPIPE */
 272                         rc = send(LogFile, p, last_chr + 1 - p, MSG_NOSIGNAL);
 273                         if (rc < 0) {
 274                                 /* I don't think looping forever on EAGAIN is a good idea.
 275                                  * Imagine that syslogd is SIGSTOPed... */
 276                                 if (/* (errno != EAGAIN) && */ (errno != EINTR)) {
 277                                         closelog_intern(1); /* 1: do not reset LogXXX globals to default */
 278                                         goto write_err;
 279                                 }
 280                                 rc = 0;
 281                         }
 282                         p += rc;
 283                 } while (p <= last_chr);
 284                 goto getout;
 285         }
 286
 287  write_err:
 288         /*
 289          * Output the message to the console; don't worry about blocking,
 290          * if console blocks everything will.  Make sure the error reported
 291          * is the one from the syslogd failure.
 292          */
 293         /* should mode be O_WRONLY | O_NOCTTY? -- Uli */
 294         /* yes, but in Linux "/dev/console" never becomes ctty anyway -- vda */
 295         if ((LogStat & LOG_CONS) &&
 296             (fd = open(_PATH_CONSOLE, O_WRONLY | O_NOCTTY)) >= 0) {
 297                 p = strchr(tbuf, '>') + 1;
 298                 last_chr[0] = '\r';
 299                 last_chr[1] = '\n';
 300                 (void)write(fd, p, last_chr - p + 2);
 301                 (void)close(fd);
 302         }
 303
 304  getout:
 305         __UCLIBC_MUTEX_UNLOCK(mylock);
 306 }
 307 #ifdef __USE_BSD
 308 strong_alias(__vsyslog,vsyslog)
 309 #endif
 310
 311 void
 312 syslog(int pri, const char *fmt, ...)
 313 {
 314         va_list ap;
 315
 316         va_start(ap, fmt);
 317         __vsyslog(pri, fmt, ap);
 318         va_end(ap);
 319 }
 320 libc_hidden_def(syslog)
 321
 322 /*
 323  * CLOSELOG -- close the system log
 324  */
 325 void
 326 closelog(void)
 327 {
 328         __UCLIBC_MUTEX_LOCK(mylock);
 329         closelog_intern(0); /* 0: reset LogXXX globals to default */
 330         __UCLIBC_MUTEX_UNLOCK(mylock);
 331 }
 332
 333 /* setlogmask -- set the log mask level */
 334 int setlogmask(int pmask)
 335 {
 336         int omask;
 337
 338         omask = LogMask;
 339         if (pmask != 0) {
 340 /*              __UCLIBC_MUTEX_LOCK(mylock);*/
 341                 LogMask = pmask;
 342 /*              __UCLIBC_MUTEX_UNLOCK(mylock);*/
 343         }
 344         return omask;
 345 }