lib/libc/gen/syslog.c

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