xref: /minix/lib/libc/gen/syslog.c (revision 90b80121) 
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 }
587