pjdlog.c revision 219385 
1/*-
2 * Copyright (c) 2009-2010 The FreeBSD Foundation
3 * Copyright (c) 2011 Pawel Jakub Dawidek <pjd@FreeBSD.org>
4 * All rights reserved.
5 *
6 * This software was developed by Pawel Jakub Dawidek under sponsorship from
7 * the FreeBSD Foundation.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 *    notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 *    notice, this list of conditions and the following disclaimer in the
16 *    documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 */
30
31#include <sys/cdefs.h>
32__FBSDID("$FreeBSD: head/sbin/hastd/pjdlog.c 219385 2011-03-07 19:54:51Z pjd $");
33
34#include <sys/socket.h>
35#include <netinet/in.h>
36
37#include <assert.h>
38#include <errno.h>
39#include <libutil.h>
40#include <printf.h>
41#include <stdarg.h>
42#include <stdint.h>
43#include <stdio.h>
44#include <stdlib.h>
45#include <string.h>
46#include <syslog.h>
47
48#include "pjdlog.h"
49
50#define	PJDLOG_NEVER_INITIALIZED	0
51#define	PJDLOG_NOT_INITIALIZED		1
52#define	PJDLOG_INITIALIZED		2
53
54static int pjdlog_initialized = PJDLOG_NEVER_INITIALIZED;
55static int pjdlog_mode, pjdlog_debug_level;
56static char pjdlog_prefix[128];
57
58static int
59pjdlog_printf_arginfo_humanized_number(const struct printf_info *pi __unused,
60    size_t n, int *argt)
61{
62
63	assert(n >= 1);
64	argt[0] = PA_INT | PA_FLAG_INTMAX;
65	return (1);
66}
67
68static int
69pjdlog_printf_render_humanized_number(struct __printf_io *io,
70    const struct printf_info *pi, const void * const *arg)
71{
72	char buf[5];
73	intmax_t num;
74	int ret;
75
76	num = *(const intmax_t *)arg[0];
77	humanize_number(buf, sizeof(buf), (int64_t)num, "", HN_AUTOSCALE,
78	    HN_NOSPACE | HN_DECIMAL);
79	ret = __printf_out(io, pi, buf, strlen(buf));
80	__printf_flush(io);
81	return (ret);
82}
83
84static int
85pjdlog_printf_arginfo_sockaddr(const struct printf_info *pi __unused,
86    size_t n, int *argt)
87{
88
89	assert(n >= 1);
90	argt[0] = PA_POINTER;
91	return (1);
92}
93
94static int
95pjdlog_printf_render_sockaddr(struct __printf_io *io,
96    const struct printf_info *pi, const void * const *arg)
97{
98	const struct sockaddr_storage *ss;
99	char buf[64];
100	int ret;
101
102	ss = *(const struct sockaddr_storage * const *)arg[0];
103	switch (ss->ss_family) {
104	case AF_INET:
105	    {
106		const struct sockaddr_in *sin;
107		in_addr_t ip;
108		unsigned int port;
109
110		sin = (const struct sockaddr_in *)ss;
111		ip = ntohl(sin->sin_addr.s_addr);
112		port = ntohs(sin->sin_port);
113
114		snprintf(buf, sizeof(buf), "%u.%u.%u.%u:%u",
115		    ((ip >> 24) & 0xff), ((ip >> 16) & 0xff),
116		    ((ip >> 8) & 0xff), (ip & 0xff), port);
117		break;
118	    }
119	default:
120		snprintf(buf, sizeof(buf), "[unsupported family %u]",
121		    (unsigned int)ss->ss_family);
122		break;
123	}
124	ret = __printf_out(io, pi, buf, strlen(buf));
125	__printf_flush(io);
126	return (ret);
127}
128
129void
130pjdlog_init(int mode)
131{
132
133	assert(pjdlog_initialized == PJDLOG_NEVER_INITIALIZED ||
134	    pjdlog_initialized == PJDLOG_NOT_INITIALIZED);
135	assert(mode == PJDLOG_MODE_STD || mode == PJDLOG_MODE_SYSLOG);
136
137	if (pjdlog_initialized == PJDLOG_NEVER_INITIALIZED) {
138		__use_xprintf = 1;
139		register_printf_render_std("T");
140		register_printf_render('N',
141		    pjdlog_printf_render_humanized_number,
142		    pjdlog_printf_arginfo_humanized_number);
143		register_printf_render('S',
144		    pjdlog_printf_render_sockaddr,
145		    pjdlog_printf_arginfo_sockaddr);
146	}
147
148	if (mode == PJDLOG_MODE_SYSLOG)
149		openlog(NULL, LOG_PID | LOG_NDELAY, LOG_DAEMON);
150	pjdlog_mode = mode;
151	pjdlog_debug_level = 0;
152	bzero(pjdlog_prefix, sizeof(pjdlog_prefix));
153
154	pjdlog_initialized = PJDLOG_INITIALIZED;
155}
156
157void
158pjdlog_fini(void)
159{
160
161	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
162
163	if (pjdlog_mode == PJDLOG_MODE_SYSLOG)
164		closelog();
165
166	pjdlog_initialized = PJDLOG_NOT_INITIALIZED;
167}
168
169/*
170 * Configure where the logs should go.
171 * By default they are send to stdout/stderr, but after going into background
172 * (eg. by calling daemon(3)) application is responsible for changing mode to
173 * PJDLOG_MODE_SYSLOG, so logs will be send to syslog.
174 */
175void
176pjdlog_mode_set(int mode)
177{
178
179	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
180	assert(mode == PJDLOG_MODE_STD || mode == PJDLOG_MODE_SYSLOG);
181
182	if (pjdlog_mode == mode)
183		return;
184
185	if (mode == PJDLOG_MODE_SYSLOG)
186		openlog(NULL, LOG_PID | LOG_NDELAY, LOG_DAEMON);
187	else /* if (mode == PJDLOG_MODE_STD) */
188		closelog();
189
190	pjdlog_mode = mode;
191}
192
193/*
194 * Return current mode.
195 */
196int
197pjdlog_mode_get(void)
198{
199
200	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
201
202	return (pjdlog_mode);
203}
204
205/*
206 * Set debug level. All the logs above the level specified here will be
207 * ignored.
208 */
209void
210pjdlog_debug_set(int level)
211{
212
213	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
214	assert(level >= 0);
215
216	pjdlog_debug_level = level;
217}
218
219/*
220 * Return current debug level.
221 */
222int
223pjdlog_debug_get(void)
224{
225
226	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
227
228	return (pjdlog_debug_level);
229}
230
231/*
232 * Set prefix that will be used before each log.
233 * Setting prefix to NULL will remove it.
234 */
235void
236pjdlog_prefix_set(const char *fmt, ...)
237{
238	va_list ap;
239
240	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
241
242	va_start(ap, fmt);
243	pjdlogv_prefix_set(fmt, ap);
244	va_end(ap);
245}
246
247/*
248 * Set prefix that will be used before each log.
249 * Setting prefix to NULL will remove it.
250 */
251void
252pjdlogv_prefix_set(const char *fmt, va_list ap)
253{
254
255	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
256	assert(fmt != NULL);
257
258	vsnprintf(pjdlog_prefix, sizeof(pjdlog_prefix), fmt, ap);
259}
260
261/*
262 * Convert log level into string.
263 */
264static const char *
265pjdlog_level_string(int loglevel)
266{
267
268	switch (loglevel) {
269	case LOG_EMERG:
270		return ("EMERG");
271	case LOG_ALERT:
272		return ("ALERT");
273	case LOG_CRIT:
274		return ("CRIT");
275	case LOG_ERR:
276		return ("ERROR");
277	case LOG_WARNING:
278		return ("WARNING");
279	case LOG_NOTICE:
280		return ("NOTICE");
281	case LOG_INFO:
282		return ("INFO");
283	case LOG_DEBUG:
284		return ("DEBUG");
285	}
286	assert(!"Invalid log level.");
287	abort();	/* XXX: gcc */
288}
289
290/*
291 * Common log routine.
292 */
293void
294pjdlog_common(int loglevel, int debuglevel, int error, const char *fmt, ...)
295{
296	va_list ap;
297
298	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
299
300	va_start(ap, fmt);
301	pjdlogv_common(loglevel, debuglevel, error, fmt, ap);
302	va_end(ap);
303}
304
305/*
306 * Common log routine, which can handle regular log level as well as debug
307 * level. We decide here where to send the logs (stdout/stderr or syslog).
308 */
309void
310pjdlogv_common(int loglevel, int debuglevel, int error, const char *fmt,
311    va_list ap)
312{
313
314	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
315	assert(loglevel == LOG_EMERG || loglevel == LOG_ALERT ||
316	    loglevel == LOG_CRIT || loglevel == LOG_ERR ||
317	    loglevel == LOG_WARNING || loglevel == LOG_NOTICE ||
318	    loglevel == LOG_INFO || loglevel == LOG_DEBUG);
319	assert(loglevel != LOG_DEBUG || debuglevel > 0);
320	assert(error >= -1);
321
322	/* Ignore debug above configured level. */
323	if (loglevel == LOG_DEBUG && debuglevel > pjdlog_debug_level)
324		return;
325
326	switch (pjdlog_mode) {
327	case PJDLOG_MODE_STD:
328	    {
329		FILE *out;
330
331		/*
332		 * We send errors and warning to stderr and the rest to stdout.
333		 */
334		switch (loglevel) {
335		case LOG_EMERG:
336		case LOG_ALERT:
337		case LOG_CRIT:
338		case LOG_ERR:
339		case LOG_WARNING:
340			out = stderr;
341			break;
342		case LOG_NOTICE:
343		case LOG_INFO:
344		case LOG_DEBUG:
345			out = stdout;
346			break;
347		default:
348			assert(!"Invalid loglevel.");
349			abort();	/* XXX: gcc */
350		}
351
352		fprintf(out, "[%s]", pjdlog_level_string(loglevel));
353		/* Attach debuglevel if this is debug log. */
354		if (loglevel == LOG_DEBUG)
355			fprintf(out, "[%d]", debuglevel);
356		fprintf(out, " %s", pjdlog_prefix);
357		vfprintf(out, fmt, ap);
358		if (error != -1)
359			fprintf(out, ": %s.", strerror(error));
360		fprintf(out, "\n");
361		fflush(out);
362		break;
363	    }
364	case PJDLOG_MODE_SYSLOG:
365	    {
366		char log[1024];
367		int len;
368
369		len = snprintf(log, sizeof(log), "%s", pjdlog_prefix);
370		if ((size_t)len < sizeof(log))
371			len += vsnprintf(log + len, sizeof(log) - len, fmt, ap);
372		if (error != -1 && (size_t)len < sizeof(log)) {
373			(void)snprintf(log + len, sizeof(log) - len, ": %s.",
374			    strerror(error));
375		}
376		syslog(loglevel, "%s", log);
377		break;
378	    }
379	default:
380		assert(!"Invalid mode.");
381	}
382}
383
384/*
385 * Regular logs.
386 */
387void
388pjdlogv(int loglevel, const char *fmt, va_list ap)
389{
390
391	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
392
393	/* LOG_DEBUG is invalid here, pjdlogv?_debug() should be used. */
394	assert(loglevel == LOG_EMERG || loglevel == LOG_ALERT ||
395	    loglevel == LOG_CRIT || loglevel == LOG_ERR ||
396	    loglevel == LOG_WARNING || loglevel == LOG_NOTICE ||
397	    loglevel == LOG_INFO);
398
399	pjdlogv_common(loglevel, 0, -1, fmt, ap);
400}
401
402/*
403 * Regular logs.
404 */
405void
406pjdlog(int loglevel, const char *fmt, ...)
407{
408	va_list ap;
409
410	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
411
412	va_start(ap, fmt);
413	pjdlogv(loglevel, fmt, ap);
414	va_end(ap);
415}
416
417/*
418 * Debug logs.
419 */
420void
421pjdlogv_debug(int debuglevel, const char *fmt, va_list ap)
422{
423
424	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
425
426	pjdlogv_common(LOG_DEBUG, debuglevel, -1, fmt, ap);
427}
428
429/*
430 * Debug logs.
431 */
432void
433pjdlog_debug(int debuglevel, const char *fmt, ...)
434{
435	va_list ap;
436
437	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
438
439	va_start(ap, fmt);
440	pjdlogv_debug(debuglevel, fmt, ap);
441	va_end(ap);
442}
443
444/*
445 * Error logs with errno logging.
446 */
447void
448pjdlogv_errno(int loglevel, const char *fmt, va_list ap)
449{
450
451	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
452
453	pjdlogv_common(loglevel, 0, errno, fmt, ap);
454}
455
456/*
457 * Error logs with errno logging.
458 */
459void
460pjdlog_errno(int loglevel, const char *fmt, ...)
461{
462	va_list ap;
463
464	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
465
466	va_start(ap, fmt);
467	pjdlogv_errno(loglevel, fmt, ap);
468	va_end(ap);
469}
470
471/*
472 * Log error, errno and exit.
473 */
474void
475pjdlogv_exit(int exitcode, const char *fmt, va_list ap)
476{
477
478	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
479
480	pjdlogv_errno(LOG_ERR, fmt, ap);
481	exit(exitcode);
482	/* NOTREACHED */
483}
484
485/*
486 * Log error, errno and exit.
487 */
488void
489pjdlog_exit(int exitcode, const char *fmt, ...)
490{
491	va_list ap;
492
493	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
494
495	va_start(ap, fmt);
496	pjdlogv_exit(exitcode, fmt, ap);
497	/* NOTREACHED */
498	va_end(ap);
499}
500
501/*
502 * Log error and exit.
503 */
504void
505pjdlogv_exitx(int exitcode, const char *fmt, va_list ap)
506{
507
508	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
509
510	pjdlogv(LOG_ERR, fmt, ap);
511	exit(exitcode);
512	/* NOTREACHED */
513}
514
515/*
516 * Log error and exit.
517 */
518void
519pjdlog_exitx(int exitcode, const char *fmt, ...)
520{
521	va_list ap;
522
523	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
524
525	va_start(ap, fmt);
526	pjdlogv_exitx(exitcode, fmt, ap);
527	/* NOTREACHED */
528	va_end(ap);
529}
530
531/*
532 * Log failure message and exit.
533 */
534void
535pjdlog_abort(const char *func, const char *file, int line,
536    const char *failedexpr, const char *fmt, ...)
537{
538	va_list ap;
539
540	assert(pjdlog_initialized == PJDLOG_INITIALIZED);
541
542	/*
543	 * When there is no message we pass __func__ as 'fmt'.
544	 * It would be cleaner to pass NULL or "", but gcc generates a warning
545	 * for both of those.
546	 */
547	if (fmt != func) {
548		va_start(ap, fmt);
549		pjdlogv_critical(fmt, ap);
550		va_end(ap);
551	}
552	if (failedexpr == NULL) {
553		if (func == NULL) {
554			pjdlog_critical("Aborted at file %s, line %d.", file,
555			    line);
556		} else {
557			pjdlog_critical("Aborted at function %s, file %s, line %d.",
558			    func, file, line);
559		}
560	} else {
561		if (func == NULL) {
562			pjdlog_critical("Assertion failed: (%s), file %s, line %d.",
563			    failedexpr, file, line);
564		} else {
565			pjdlog_critical("Assertion failed: (%s), function %s, file %s, line %d.",
566			    failedexpr, func, file, line);
567		}
568	}
569	abort();
570}
571