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
syslog(int pri,const char * fmt,...)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
vsyslog(int pri,const char * fmt,va_list ap)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
syslogp(int pri,const char * msgid,const char * sdfmt,const char * msgfmt,...)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
vsyslogp(int pri,const char * msgid,const char * sdfmt,const char * msgfmt,va_list ap)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
openlog(const char * ident,int logstat,int logfac)127 openlog(const char *ident, int logstat, int logfac)
128 {
129 openlog_r(ident, logstat, logfac, &sdata);
130 }
131
132 void
closelog(void)133 closelog(void)
134 {
135 closelog_r(&sdata);
136 }
137
138 /* setlogmask -- set the log mask level */
139 int
setlogmask(int pmask)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
syslog_r(int pri,struct syslog_data * data,const char * fmt,...)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
syslogp_r(int pri,struct syslog_data * data,const char * msgid,const char * sdfmt,const char * msgfmt,...)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
syslog_ss(int pri,struct syslog_data * data,const char * fmt,...)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
syslogp_ss(int pri,struct syslog_data * data,const char * msgid,const char * sdfmt,const char * msgfmt,...)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
vsyslog_ss(int pri,struct syslog_data * data,const char * fmt,va_list ap)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
vsyslogp_ss(int pri,struct syslog_data * data,const char * msgid,const char * sdfmt,const char * msgfmt,va_list ap)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
vsyslog_r(int pri,struct syslog_data * data,const char * fmt,va_list ap)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
vsyslogp_r(int pri,struct syslog_data * data,const char * msgid,const char * sdfmt,const char * msgfmt,va_list ap)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
disconnectlog_r(struct syslog_data * data)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
connectlog_r(struct syslog_data * data)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
openlog_unlocked_r(const char * ident,int logstat,int logfac,struct syslog_data * data)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
openlog_r(const char * ident,int logstat,int logfac,struct syslog_data * data)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
closelog_r(struct syslog_data * data)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
setlogmask_r(int pmask,struct syslog_data * data)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 }
587