lib/libc/gen/syslog.c

   1 /*      $NetBSD: syslog.c,v 1.54 2014/09/18 13:58:20 christos Exp $     */
   2
   3 /*
   4  * Copyright (c) 1983, 1988, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #if defined(LIBC_SCCS) && !defined(lint)
  34 #if 0
  35 static char sccsid[] = "@(#)syslog.c    8.5 (Berkeley) 4/29/95";
  36 #else
  37 __RCSID("$NetBSD: syslog.c,v 1.54 2014/09/18 13:58:20 christos Exp $");
  38 #endif
  39 #endif /* LIBC_SCCS and not lint */
  40
  41 #include "namespace.h"
  42 #include <sys/types.h>
  43 #include <sys/param.h>
  44 #include <sys/socket.h>
  45 #include <sys/syslog.h>
  46 #include <sys/uio.h>
  47 #include <sys/un.h>
  48 #include <netdb.h>
  49
  50 #include <errno.h>
  51 #include <fcntl.h>
  52 #include <paths.h>
  53 #include <stdarg.h>
  54 #include <stdio.h>
  55 #include <stdlib.h>
  56 #include <string.h>
  57 #include <time.h>
  58 #include <unistd.h>
  59 #include "reentrant.h"
  60 #include "extern.h"
  61
  62 #ifdef __weak_alias
  63 __weak_alias(closelog,_closelog)
  64 __weak_alias(openlog,_openlog)
  65 __weak_alias(setlogmask,_setlogmask)
  66 __weak_alias(syslog,_syslog)
  67 __weak_alias(vsyslog,_vsyslog)
  68 __weak_alias(syslogp,_syslogp)
  69 __weak_alias(vsyslogp,_vsyslogp)
  70 #endif
  71
  72 static struct syslog_data sdata = SYSLOG_DATA_INIT;
  73
  74 static void     openlog_unlocked_r(const char *, int, int,
  75     struct syslog_data *);
  76 static void     disconnectlog_r(struct syslog_data *);
  77 static void     connectlog_r(struct syslog_data *);
  78
  79 #define LOG_SIGNAL_SAFE (int)0x80000000
  80
  81
  82 #ifdef _REENTRANT
  83 static mutex_t  syslog_mutex = MUTEX_INITIALIZER;
  84 #endif
  85
  86 /*
  87  * syslog, vsyslog --
  88  *      print message on log file; output is intended for syslogd(8).
  89  */
  90 void
  91 syslog(int pri, const char *fmt, ...)
  92 {
  93         va_list ap;
  94
  95         va_start(ap, fmt);
  96         vsyslog(pri, fmt, ap);
  97         va_end(ap);
  98 }
  99
 100 void
 101 vsyslog(int pri, const char *fmt, va_list ap)
 102 {
 103         vsyslog_r(pri, &sdata, fmt, ap);
 104 }
 105
 106 /*
 107  * syslogp, vsyslogp --
 108  *      like syslog but take additional arguments for MSGID and SD
 109  */
 110 void
 111 syslogp(int pri, const char *msgid, const char *sdfmt, const char *msgfmt, ...)
 112 {
 113         va_list ap;
 114
 115         va_start(ap, msgfmt);
 116         vsyslogp(pri, msgid, sdfmt, msgfmt, ap);
 117         va_end(ap);
 118 }
 119
 120 void
 121 vsyslogp(int pri, const char *msgid, const char *sdfmt, const char *msgfmt, va_list ap)
 122 {
 123         vsyslogp_r(pri, &sdata, msgid, sdfmt, msgfmt, ap);
 124 }
 125
 126 void
 127 openlog(const char *ident, int logstat, int logfac)
 128 {
 129         openlog_r(ident, logstat, logfac, &sdata);
 130 }
 131
 132 void
 133 closelog(void)
 134 {
 135         closelog_r(&sdata);
 136 }
 137
 138 /* setlogmask -- set the log mask level */
 139 int
 140 setlogmask(int pmask)
 141 {
 142         return setlogmask_r(pmask, &sdata);
 143 }
 144
 145 /* Reentrant version of syslog, i.e. syslog_r() */
 146
 147 void
 148 syslog_r(int pri, struct syslog_data *data, const char *fmt, ...)
 149 {
 150         va_list ap;
 151
 152         va_start(ap, fmt);
 153         vsyslog_r(pri, data, fmt, ap);
 154         va_end(ap);
 155 }
 156
 157 void
 158 syslogp_r(int pri, struct syslog_data *data, const char *msgid,
 159         const char *sdfmt, const char *msgfmt, ...)
 160 {
 161         va_list ap;
 162
 163         va_start(ap, msgfmt);
 164         vsyslogp_r(pri, data, msgid, sdfmt, msgfmt, ap);
 165         va_end(ap);
 166 }
 167
 168 void
 169 syslog_ss(int pri, struct syslog_data *data, const char *fmt, ...)
 170 {
 171         va_list ap;
 172
 173         va_start(ap, fmt);
 174         vsyslog_r(pri | LOG_SIGNAL_SAFE, data, fmt, ap);
 175         va_end(ap);
 176 }
 177
 178 void
 179 syslogp_ss(int pri, struct syslog_data *data, const char *msgid,
 180         const char *sdfmt, const char *msgfmt, ...)
 181 {
 182         va_list ap;
 183
 184         va_start(ap, msgfmt);
 185         vsyslogp_r(pri | LOG_SIGNAL_SAFE, data, msgid, sdfmt, msgfmt, ap);
 186         va_end(ap);
 187 }
 188
 189 void
 190 vsyslog_ss(int pri, struct syslog_data *data, const char *fmt, va_list ap)
 191 {
 192         vsyslog_r(pri | LOG_SIGNAL_SAFE, data, fmt, ap);
 193 }
 194
 195 void
 196 vsyslogp_ss(int pri, struct syslog_data *data, const char *msgid,
 197         const char *sdfmt, const char *msgfmt, va_list ap)
 198 {
 199         vsyslogp_r(pri | LOG_SIGNAL_SAFE, data, msgid, sdfmt, msgfmt, ap);
 200 }
 201
 202
 203 void
 204 vsyslog_r(int pri, struct syslog_data *data, const char *fmt, va_list ap)
 205 {
 206         vsyslogp_r(pri, data, NULL, NULL, fmt, ap);
 207 }
 208
 209 void
 210 vsyslogp_r(int pri, struct syslog_data *data, const char *msgid,
 211         const char *sdfmt, const char *msgfmt, va_list ap)
 212 {
 213         static const char BRCOSP[] = "]: ";
 214         static const char CRLF[] = "\r\n";
 215         size_t cnt, prlen, tries;
 216         char ch, *p, *t;
 217         struct timeval tv;
 218         struct tm tmnow;
 219         time_t now;
 220         int fd, saved_errno;
 221 #define TBUF_LEN        2048
 222 #define FMT_LEN         1024
 223 #define MAXTRIES        10
 224         char tbuf[TBUF_LEN], fmt_cpy[FMT_LEN], fmt_cat[FMT_LEN] = "";
 225         size_t tbuf_left, fmt_left, msgsdlen;
 226         char *fmt = fmt_cat;
 227         int signal_safe = pri & LOG_SIGNAL_SAFE;
 228         struct iovec iov[7];    /* prog + [ + pid + ]: + fmt + crlf */
 229         int opened, iovcnt;
 230
 231         pri &= ~LOG_SIGNAL_SAFE;
 232
 233 #define INTERNALLOG     LOG_ERR|LOG_CONS|LOG_PERROR|LOG_PID
 234         /* Check for invalid bits. */
 235         if (pri & ~(LOG_PRIMASK|LOG_FACMASK)) {
 236                 syslog_r(INTERNALLOG | signal_safe, data,
 237                     "syslog_r: unknown facility/priority: %x", pri);
 238                 pri &= LOG_PRIMASK|LOG_FACMASK;
 239         }
 240
 241         /* Check priority against setlogmask values. */
 242         if (!(LOG_MASK(LOG_PRI(pri)) & data->log_mask))
 243                 return;
 244
 245         saved_errno = errno;
 246
 247         /* Set default facility if none specified. */
 248         if ((pri & LOG_FACMASK) == 0)
 249                 pri |= data->log_fac;
 250
 251         /* Build the message. */
 252         p = tbuf;
 253         tbuf_left = TBUF_LEN;
 254
 255 #define DEC()                                                   \
 256         do {                                                    \
 257                 if (prlen >= tbuf_left)                         \
 258                         prlen = tbuf_left - 1;                  \
 259                 p += prlen;                                     \
 260                 tbuf_left -= prlen;                             \
 261         } while (/*CONSTCOND*/0)
 262
 263         prlen = snprintf_ss(p, tbuf_left, "<%d>1 ", pri);
 264         DEC();
 265
 266         if (!signal_safe && (gettimeofday(&tv, NULL) != -1)) {
 267                 /* strftime() implies tzset(), localtime_r() doesn't. */
 268                 tzset();
 269                 now = (time_t) tv.tv_sec;
 270                 localtime_r(&now, &tmnow);
 271
 272                 prlen = strftime(p, tbuf_left, "%FT%T", &tmnow);
 273                 DEC();
 274                 prlen = snprintf(p, tbuf_left, ".%06ld", (long)tv.tv_usec);
 275                 DEC();
 276                 prlen = strftime(p, tbuf_left-1, "%z", &tmnow);
 277                 /* strftime gives eg. "+0200", but we need "+02:00" */
 278                 if (prlen == 5) {
 279                         p[prlen+1] = p[prlen];
 280                         p[prlen]   = p[prlen-1];
 281                         p[prlen-1] = p[prlen-2];
 282                         p[prlen-2] = ':';
 283                         prlen += 1;
 284                 }
 285         } else {
 286                 prlen = snprintf_ss(p, tbuf_left, "-");
 287 #if 0
 288                 /*
 289                  * if gmtime_r() was signal-safe we could output
 290                  * the UTC-time:
 291                  */
 292                 gmtime_r(&now, &tmnow);
 293                 prlen = strftime(p, tbuf_left, "%FT%TZ", &tmnow);
 294 #endif
 295         }
 296
 297 #if !defined(__minix)
 298         if (data == &sdata)
 299                 mutex_lock(&syslog_mutex);
 300 #endif /* !defined(__minix) */
 301
 302         if (data->log_hostname[0] == '\0' && gethostname(data->log_hostname,
 303             sizeof(data->log_hostname)) == -1) {
 304                 /* can this really happen? */
 305                 data->log_hostname[0] = '-';
 306                 data->log_hostname[1] = '\0';
 307         }
 308
 309         DEC();
 310         prlen = snprintf_ss(p, tbuf_left, " %s ", data->log_hostname);
 311
 312         if (data->log_tag == NULL)
 313                 data->log_tag = getprogname();
 314
 315         DEC();
 316         prlen = snprintf_ss(p, tbuf_left, "%s ",
 317             data->log_tag ? data->log_tag : "-");
 318
 319 #if !defined(__minix)
 320         if (data == &sdata)
 321                 mutex_unlock(&syslog_mutex);
 322 #endif /* !defined(__minix) */
 323
 324         if (data->log_stat & (LOG_PERROR|LOG_CONS)) {
 325                 iovcnt = 0;
 326                 iov[iovcnt].iov_base = p;
 327                 iov[iovcnt].iov_len = prlen - 1;
 328                 iovcnt++;
 329         }
 330         DEC();
 331
 332         if (data->log_stat & LOG_PID) {
 333                 prlen = snprintf_ss(p, tbuf_left, "%d ", getpid());
 334                 if (data->log_stat & (LOG_PERROR|LOG_CONS)) {
 335                         iov[iovcnt].iov_base = __UNCONST("[");
 336                         iov[iovcnt].iov_len = 1;
 337                         iovcnt++;
 338                         iov[iovcnt].iov_base = p;
 339                         iov[iovcnt].iov_len = prlen - 1;
 340                         iovcnt++;
 341                         iov[iovcnt].iov_base = __UNCONST(BRCOSP);
 342                         iov[iovcnt].iov_len = 3;
 343                         iovcnt++;
 344                 }
 345         } else {
 346                 prlen = snprintf_ss(p, tbuf_left, "- ");
 347                 if (data->log_stat & (LOG_PERROR|LOG_CONS)) {
 348                         iov[iovcnt].iov_base = __UNCONST(BRCOSP + 1);
 349                         iov[iovcnt].iov_len = 2;
 350                         iovcnt++;
 351                 }
 352         }
 353         DEC();
 354
 355         /*
 356          * concat the format strings, then use one vsnprintf()
 357          */
 358         if (msgid != NULL && *msgid != '\0') {
 359                 strlcat(fmt_cat, msgid, FMT_LEN);
 360                 strlcat(fmt_cat, " ", FMT_LEN);
 361         } else
 362                 strlcat(fmt_cat, "- ", FMT_LEN);
 363
 364         if (sdfmt != NULL && *sdfmt != '\0') {
 365                 strlcat(fmt_cat, sdfmt, FMT_LEN);
 366         } else
 367                 strlcat(fmt_cat, "-", FMT_LEN);
 368
 369         if (data->log_stat & (LOG_PERROR|LOG_CONS))
 370                 msgsdlen = strlen(fmt_cat) + 1;
 371         else
 372                 msgsdlen = 0;   /* XXX: GCC */
 373
 374         if (msgfmt != NULL && *msgfmt != '\0') {
 375                 strlcat(fmt_cat, " ", FMT_LEN);
 376                 strlcat(fmt_cat, msgfmt, FMT_LEN);
 377         }
 378
 379         /*
 380          * We wouldn't need this mess if printf handled %m, or if
 381          * strerror() had been invented before syslog().
 382          */
 383         for (t = fmt_cpy, fmt_left = FMT_LEN; (ch = *fmt) != '\0'; ++fmt) {
 384                 if (ch == '%' && fmt[1] == 'm') {
 385                         char ebuf[128];
 386                         ++fmt;
 387                         if (signal_safe ||
 388                             strerror_r(saved_errno, ebuf, sizeof(ebuf)))
 389                                 prlen = snprintf_ss(t, fmt_left, "Error %d",
 390                                     saved_errno);
 391                         else
 392                                 prlen = snprintf_ss(t, fmt_left, "%s", ebuf);
 393                         if (prlen >= fmt_left)
 394                                 prlen = fmt_left - 1;
 395                         t += prlen;
 396                         fmt_left -= prlen;
 397                 } else if (ch == '%' && fmt[1] == '%' && fmt_left > 2) {
 398                         *t++ = '%';
 399                         *t++ = '%';
 400                         fmt++;
 401                         fmt_left -= 2;
 402                 } else {
 403                         if (fmt_left > 1) {
 404                                 *t++ = ch;
 405                                 fmt_left--;
 406                         }
 407                 }
 408         }
 409         *t = '\0';
 410
 411         if (signal_safe)
 412                 prlen = vsnprintf_ss(p, tbuf_left, fmt_cpy, ap);
 413         else
 414                 prlen = vsnprintf(p, tbuf_left, fmt_cpy, ap);
 415
 416         if (data->log_stat & (LOG_PERROR|LOG_CONS)) {
 417                 iov[iovcnt].iov_base = p + msgsdlen;
 418                 iov[iovcnt].iov_len = prlen - msgsdlen;
 419                 iovcnt++;
 420         }
 421
 422         DEC();
 423         cnt = p - tbuf;
 424
 425         /* Output to stderr if requested. */
 426         if (data->log_stat & LOG_PERROR) {
 427                 iov[iovcnt].iov_base = __UNCONST(CRLF + 1);
 428                 iov[iovcnt].iov_len = 1;
 429                 (void)writev(STDERR_FILENO, iov, iovcnt + 1);
 430         }
 431
 432         /* Get connected, output the message to the local logger. */
 433 #if !defined(__minix)
 434         if (data == &sdata)
 435                 mutex_lock(&syslog_mutex);
 436 #endif /* !defined(__minix) */
 437         opened = !data->log_opened;
 438         if (opened)
 439                 openlog_unlocked_r(data->log_tag, data->log_stat, 0, data);
 440         connectlog_r(data);
 441
 442         /*
 443          * If the send() failed, there are two likely scenarios:
 444          *  1) syslogd was restarted
 445          *  2) /dev/log is out of socket buffer space
 446          * We attempt to reconnect to /dev/log to take care of
 447          * case #1 and keep send()ing data to cover case #2
 448          * to give syslogd a chance to empty its socket buffer.
 449          */
 450         for (tries = 0; tries < MAXTRIES; tries++) {
 451                 if (send(data->log_file, tbuf, cnt, 0) != -1)
 452                         break;
 453                 if (errno != ENOBUFS) {
 454                         disconnectlog_r(data);
 455                         connectlog_r(data);
 456                 } else
 457                         (void)usleep(1);
 458         }
 459
 460         /*
 461          * Output the message to the console; try not to block
 462          * as a blocking console should not stop other processes.
 463          * Make sure the error reported is the one from the syslogd failure.
 464          */
 465         if (tries == MAXTRIES && (data->log_stat & LOG_CONS) &&
 466             (fd = open(_PATH_CONSOLE,
 467                 O_WRONLY | O_NONBLOCK | O_CLOEXEC, 0)) >= 0) {
 468                 iov[iovcnt].iov_base = __UNCONST(CRLF);
 469                 iov[iovcnt].iov_len = 2;
 470                 (void)writev(fd, iov, iovcnt + 1);
 471                 (void)close(fd);
 472         }
 473
 474 #if !defined(__minix)
 475         if (data == &sdata)
 476                 mutex_unlock(&syslog_mutex);
 477 #endif /* !defined(__minix) */
 478
 479         if (data != &sdata && opened) {
 480                 /* preserve log tag */
 481                 const char *ident = data->log_tag;
 482                 closelog_r(data);
 483                 data->log_tag = ident;
 484         }
 485 }
 486
 487 static void
 488 disconnectlog_r(struct syslog_data *data)
 489 {
 490         /*
 491          * If the user closed the FD and opened another in the same slot,
 492          * that's their problem.  They should close it before calling on
 493          * system services.
 494          */
 495         if (data->log_file != -1) {
 496                 (void)close(data->log_file);
 497                 data->log_file = -1;
 498         }
 499         data->log_connected = 0;                /* retry connect */
 500 }
 501
 502 static void
 503 connectlog_r(struct syslog_data *data)
 504 {
 505         /* AF_UNIX address of local logger */
 506         static const struct sockaddr_un sun = {
 507                 .sun_family = AF_LOCAL,
 508                 .sun_len = sizeof(sun),
 509                 .sun_path = _PATH_LOG,
 510         };
 511
 512         if (data->log_file == -1 || fcntl(data->log_file, F_GETFL, 0) == -1) {
 513                 if ((data->log_file = socket(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC,
 514                     0)) == -1)
 515                         return;
 516                 data->log_connected = 0;
 517         }
 518         if (!data->log_connected) {
 519                 if (connect(data->log_file,
 520                     (const struct sockaddr *)(const void *)&sun,
 521                     (socklen_t)sizeof(sun)) == -1)
 522                 {
 523                         (void)close(data->log_file);
 524                         data->log_file = -1;
 525                 } else
 526                         data->log_connected = 1;
 527         }
 528 }
 529
 530 static void
 531 openlog_unlocked_r(const char *ident, int logstat, int logfac,
 532     struct syslog_data *data)
 533 {
 534         if (ident != NULL)
 535                 data->log_tag = ident;
 536         data->log_stat = logstat;
 537         if (logfac != 0 && (logfac &~ LOG_FACMASK) == 0)
 538                 data->log_fac = logfac;
 539
 540         if (data->log_stat & LOG_NDELAY)        /* open immediately */
 541                 connectlog_r(data);
 542
 543         data->log_opened = 1;
 544 }
 545
 546 void
 547 openlog_r(const char *ident, int logstat, int logfac, struct syslog_data *data)
 548 {
 549 #if !defined(__minix)
 550         if (data == &sdata)
 551                 mutex_lock(&syslog_mutex);
 552 #endif /* !defined(__minix) */
 553         openlog_unlocked_r(ident, logstat, logfac, data);
 554 #if !defined(__minix)
 555         if (data == &sdata)
 556                 mutex_unlock(&syslog_mutex);
 557 #endif /* !defined(__minix) */
 558 }
 559
 560 void
 561 closelog_r(struct syslog_data *data)
 562 {
 563 #if !defined(__minix)
 564         if (data == &sdata)
 565                 mutex_lock(&syslog_mutex);
 566 #endif /* !defined(__minix) */
 567         (void)close(data->log_file);
 568         data->log_file = -1;
 569         data->log_connected = 0;
 570         data->log_tag = NULL;
 571 #if !defined(__minix)
 572         if (data == &sdata)
 573                 mutex_unlock(&syslog_mutex);
 574 #endif /* !defined(__minix) */
 575 }
 576
 577 int
 578 setlogmask_r(int pmask, struct syslog_data *data)
 579 {
 580         int omask;
 581
 582         omask = data->log_mask;
 583         if (pmask != 0)
 584                 data->log_mask = pmask;
 585         return omask;
 586 }