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