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$");
33
34 #include <sys/types.h>
35 #include <sys/socket.h>
36 #include <sys/un.h>
37 #include <netinet/in.h>
38 #include <arpa/inet.h>
39
40 #include <assert.h>
41 #include <errno.h>
42 #include <libutil.h>
43 #include <limits.h>
44 #include <printf.h>
45 #include <stdarg.h>
46 #include <stdint.h>
47 #include <stdio.h>
48 #include <stdlib.h>
49 #include <string.h>
50 #include <syslog.h>
51 #include <unistd.h>
52
53 #ifdef notyet
54 #include <robustio.h>
55 #endif
56
57 #include "pjdlog.h"
58
59 #ifndef MAX
60 #define MAX(a, b) ((a) > (b) ? (a) : (b))
61 #endif
62
63 #define PJDLOG_MAX_MSGSIZE 4096
64
65 #define PJDLOG_PREFIX_STACK 4
66 #define PJDLOG_PREFIX_MAXSIZE 128
67
68 #define PJDLOG_NEVER_INITIALIZED 0
69 #define PJDLOG_NOT_INITIALIZED 1
70 #define PJDLOG_INITIALIZED 2
71
72 static int pjdlog_initialized = PJDLOG_NEVER_INITIALIZED;
73 static int pjdlog_mode, pjdlog_debug_level, pjdlog_sock;
74 static int pjdlog_prefix_current;
75 static char pjdlog_prefix[PJDLOG_PREFIX_STACK][PJDLOG_PREFIX_MAXSIZE];
76
77 static int
pjdlog_printf_arginfo_humanized_number(const struct printf_info * pi __unused,size_t n,int * argt)78 pjdlog_printf_arginfo_humanized_number(const struct printf_info *pi __unused,
79 size_t n, int *argt)
80 {
81
82 assert(n >= 1);
83 argt[0] = PA_INT | PA_FLAG_INTMAX;
84 return (1);
85 }
86
87 static int
pjdlog_printf_render_humanized_number(struct __printf_io * io,const struct printf_info * pi,const void * const * arg)88 pjdlog_printf_render_humanized_number(struct __printf_io *io,
89 const struct printf_info *pi, const void * const *arg)
90 {
91 char buf[5];
92 intmax_t num;
93 int ret;
94
95 num = *(const intmax_t *)arg[0];
96 humanize_number(buf, sizeof(buf), (int64_t)num, "", HN_AUTOSCALE,
97 HN_NOSPACE | HN_DECIMAL);
98 ret = __printf_out(io, pi, buf, strlen(buf));
99 __printf_flush(io);
100 return (ret);
101 }
102
103 static int
pjdlog_printf_arginfo_sockaddr(const struct printf_info * pi __unused,size_t n,int * argt)104 pjdlog_printf_arginfo_sockaddr(const struct printf_info *pi __unused,
105 size_t n, int *argt)
106 {
107
108 assert(n >= 1);
109 argt[0] = PA_POINTER;
110 return (1);
111 }
112
113 static int
pjdlog_printf_render_sockaddr_ip(struct __printf_io * io,const struct printf_info * pi,const void * const * arg)114 pjdlog_printf_render_sockaddr_ip(struct __printf_io *io,
115 const struct printf_info *pi, const void * const *arg)
116 {
117 const struct sockaddr_storage *ss;
118 char addr[MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN)];
119 int ret;
120
121 ss = *(const struct sockaddr_storage * const *)arg[0];
122 switch (ss->ss_family) {
123 case AF_INET:
124 {
125 const struct sockaddr_in *sin;
126
127 sin = (const struct sockaddr_in *)ss;
128 if (inet_ntop(ss->ss_family, &sin->sin_addr, addr,
129 sizeof(addr)) == NULL) {
130 PJDLOG_ABORT("inet_ntop(AF_INET) failed: %s.",
131 strerror(errno));
132 }
133 break;
134 }
135 case AF_INET6:
136 {
137 const struct sockaddr_in6 *sin;
138
139 sin = (const struct sockaddr_in6 *)ss;
140 if (inet_ntop(ss->ss_family, &sin->sin6_addr, addr,
141 sizeof(addr)) == NULL) {
142 PJDLOG_ABORT("inet_ntop(AF_INET6) failed: %s.",
143 strerror(errno));
144 }
145 break;
146 }
147 default:
148 snprintf(addr, sizeof(addr), "[unsupported family %hhu]",
149 ss->ss_family);
150 break;
151 }
152 ret = __printf_out(io, pi, addr, strlen(addr));
153 __printf_flush(io);
154 return (ret);
155 }
156
157 static int
pjdlog_printf_render_sockaddr(struct __printf_io * io,const struct printf_info * pi,const void * const * arg)158 pjdlog_printf_render_sockaddr(struct __printf_io *io,
159 const struct printf_info *pi, const void * const *arg)
160 {
161 const struct sockaddr_storage *ss;
162 char buf[PATH_MAX];
163 int ret;
164
165 ss = *(const struct sockaddr_storage * const *)arg[0];
166 switch (ss->ss_family) {
167 case AF_UNIX:
168 {
169 const struct sockaddr_un *sun;
170
171 sun = (const struct sockaddr_un *)ss;
172 if (sun->sun_path[0] == '\0')
173 snprintf(buf, sizeof(buf), "N/A");
174 else
175 snprintf(buf, sizeof(buf), "%s", sun->sun_path);
176 break;
177 }
178 case AF_INET:
179 {
180 char addr[INET_ADDRSTRLEN];
181 const struct sockaddr_in *sin;
182 unsigned int port;
183
184 sin = (const struct sockaddr_in *)ss;
185 port = ntohs(sin->sin_port);
186 if (inet_ntop(ss->ss_family, &sin->sin_addr, addr,
187 sizeof(addr)) == NULL) {
188 PJDLOG_ABORT("inet_ntop(AF_INET) failed: %s.",
189 strerror(errno));
190 }
191 snprintf(buf, sizeof(buf), "%s:%u", addr, port);
192 break;
193 }
194 case AF_INET6:
195 {
196 char addr[INET6_ADDRSTRLEN];
197 const struct sockaddr_in6 *sin;
198 unsigned int port;
199
200 sin = (const struct sockaddr_in6 *)ss;
201 port = ntohs(sin->sin6_port);
202 if (inet_ntop(ss->ss_family, &sin->sin6_addr, addr,
203 sizeof(addr)) == NULL) {
204 PJDLOG_ABORT("inet_ntop(AF_INET6) failed: %s.",
205 strerror(errno));
206 }
207 snprintf(buf, sizeof(buf), "[%s]:%u", addr, port);
208 break;
209 }
210 default:
211 snprintf(buf, sizeof(buf), "[unsupported family %hhu]",
212 ss->ss_family);
213 break;
214 }
215 ret = __printf_out(io, pi, buf, strlen(buf));
216 __printf_flush(io);
217 return (ret);
218 }
219
220 void
pjdlog_init(int mode)221 pjdlog_init(int mode)
222 {
223 int saved_errno;
224
225 assert(pjdlog_initialized == PJDLOG_NEVER_INITIALIZED ||
226 pjdlog_initialized == PJDLOG_NOT_INITIALIZED);
227 #ifdef notyet
228 assert(mode == PJDLOG_MODE_STD || mode == PJDLOG_MODE_SYSLOG ||
229 mode == PJDLOG_MODE_SOCK);
230 #else
231 assert(mode == PJDLOG_MODE_STD || mode == PJDLOG_MODE_SYSLOG);
232 #endif
233
234 saved_errno = errno;
235
236 if (pjdlog_initialized == PJDLOG_NEVER_INITIALIZED) {
237 __use_xprintf = 1;
238 register_printf_render_std("T");
239 register_printf_render('N',
240 pjdlog_printf_render_humanized_number,
241 pjdlog_printf_arginfo_humanized_number);
242 register_printf_render('I',
243 pjdlog_printf_render_sockaddr_ip,
244 pjdlog_printf_arginfo_sockaddr);
245 register_printf_render('S',
246 pjdlog_printf_render_sockaddr,
247 pjdlog_printf_arginfo_sockaddr);
248 }
249
250 if (mode == PJDLOG_MODE_SYSLOG)
251 openlog(NULL, LOG_PID | LOG_NDELAY, LOG_LOCAL0);
252 pjdlog_mode = mode;
253 pjdlog_debug_level = 0;
254 pjdlog_prefix_current = 0;
255 pjdlog_prefix[0][0] = '\0';
256
257 pjdlog_initialized = PJDLOG_INITIALIZED;
258 pjdlog_sock = -1;
259
260 errno = saved_errno;
261 }
262
263 void
pjdlog_fini(void)264 pjdlog_fini(void)
265 {
266 int saved_errno;
267
268 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
269
270 saved_errno = errno;
271
272 if (pjdlog_mode == PJDLOG_MODE_SYSLOG)
273 closelog();
274
275 pjdlog_initialized = PJDLOG_NOT_INITIALIZED;
276 pjdlog_sock = -1;
277
278 errno = saved_errno;
279 }
280
281 /*
282 * Configure where the logs should go.
283 * By default they are send to stdout/stderr, but after going into background
284 * (eg. by calling daemon(3)) application is responsible for changing mode to
285 * PJDLOG_MODE_SYSLOG, so logs will be send to syslog.
286 */
287 void
pjdlog_mode_set(int mode)288 pjdlog_mode_set(int mode)
289 {
290 int saved_errno;
291
292 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
293 #ifdef notyet
294 assert(mode == PJDLOG_MODE_STD || mode == PJDLOG_MODE_SYSLOG ||
295 mode == PJDLOG_MODE_SOCK);
296 #else
297 assert(mode == PJDLOG_MODE_STD || mode == PJDLOG_MODE_SYSLOG);
298 #endif
299
300 if (pjdlog_mode == mode)
301 return;
302
303 saved_errno = errno;
304
305 if (mode == PJDLOG_MODE_SYSLOG)
306 openlog(NULL, LOG_PID | LOG_NDELAY, LOG_DAEMON);
307 else if (mode == PJDLOG_MODE_STD)
308 closelog();
309
310 if (mode != PJDLOG_MODE_SOCK)
311 pjdlog_sock = -1;
312
313 pjdlog_mode = mode;
314
315 errno = saved_errno;
316 }
317
318
319 /*
320 * Return current mode.
321 */
322 int
pjdlog_mode_get(void)323 pjdlog_mode_get(void)
324 {
325
326 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
327
328 return (pjdlog_mode);
329 }
330
331 #ifdef notyet
332 /*
333 * Sets socket number to use for PJDLOG_MODE_SOCK mode.
334 */
335 void
pjdlog_sock_set(int sock)336 pjdlog_sock_set(int sock)
337 {
338
339 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
340 assert(pjdlog_mode == PJDLOG_MODE_SOCK);
341 assert(sock >= 0);
342
343 pjdlog_sock = sock;
344 }
345 #endif
346
347 #ifdef notyet
348 /*
349 * Returns socket number used for PJDLOG_MODE_SOCK mode.
350 */
351 int
pjdlog_sock_get(void)352 pjdlog_sock_get(void)
353 {
354
355 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
356 assert(pjdlog_mode == PJDLOG_MODE_SOCK);
357 assert(pjdlog_sock >= 0);
358
359 return (pjdlog_sock);
360 }
361 #endif
362
363 /*
364 * Set debug level. All the logs above the level specified here will be
365 * ignored.
366 */
367 void
pjdlog_debug_set(int level)368 pjdlog_debug_set(int level)
369 {
370
371 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
372 assert(level >= 0);
373 assert(level <= 127);
374
375 pjdlog_debug_level = level;
376 }
377
378 /*
379 * Return current debug level.
380 */
381 int
pjdlog_debug_get(void)382 pjdlog_debug_get(void)
383 {
384
385 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
386
387 return (pjdlog_debug_level);
388 }
389
390 /*
391 * Set prefix that will be used before each log.
392 */
393 void
pjdlog_prefix_set(const char * fmt,...)394 pjdlog_prefix_set(const char *fmt, ...)
395 {
396 va_list ap;
397
398 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
399
400 va_start(ap, fmt);
401 pjdlogv_prefix_set(fmt, ap);
402 va_end(ap);
403 }
404
405 /*
406 * Set prefix that will be used before each log.
407 */
408 void
pjdlogv_prefix_set(const char * fmt,va_list ap)409 pjdlogv_prefix_set(const char *fmt, va_list ap)
410 {
411 int saved_errno;
412
413 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
414 assert(fmt != NULL);
415
416 saved_errno = errno;
417
418 vsnprintf(pjdlog_prefix[pjdlog_prefix_current],
419 sizeof(pjdlog_prefix[pjdlog_prefix_current]), fmt, ap);
420
421 errno = saved_errno;
422 }
423
424 /*
425 * Get current prefix.
426 */
427 const char *
pjdlog_prefix_get(void)428 pjdlog_prefix_get(void)
429 {
430
431 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
432
433 return (pjdlog_prefix[pjdlog_prefix_current]);
434 }
435
436 /*
437 * Set new prefix and put the current one on the stack.
438 */
439 void
pjdlog_prefix_push(const char * fmt,...)440 pjdlog_prefix_push(const char *fmt, ...)
441 {
442 va_list ap;
443
444 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
445
446 va_start(ap, fmt);
447 pjdlogv_prefix_push(fmt, ap);
448 va_end(ap);
449 }
450
451 /*
452 * Set new prefix and put the current one on the stack.
453 */
454 void
pjdlogv_prefix_push(const char * fmt,va_list ap)455 pjdlogv_prefix_push(const char *fmt, va_list ap)
456 {
457
458 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
459 assert(pjdlog_prefix_current < PJDLOG_PREFIX_STACK - 1);
460
461 pjdlog_prefix_current++;
462
463 pjdlogv_prefix_set(fmt, ap);
464 }
465
466 /*
467 * Removes current prefix and recovers previous one from the stack.
468 */
469 void
pjdlog_prefix_pop(void)470 pjdlog_prefix_pop(void)
471 {
472
473 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
474 assert(pjdlog_prefix_current > 0);
475
476 pjdlog_prefix_current--;
477 }
478
479 /*
480 * Convert log level into string.
481 */
482 static const char *
pjdlog_level_to_string(int loglevel)483 pjdlog_level_to_string(int loglevel)
484 {
485
486 switch (loglevel) {
487 case LOG_EMERG:
488 return ("EMERG");
489 case LOG_ALERT:
490 return ("ALERT");
491 case LOG_CRIT:
492 return ("CRIT");
493 case LOG_ERR:
494 return ("ERROR");
495 case LOG_WARNING:
496 return ("WARNING");
497 case LOG_NOTICE:
498 return ("NOTICE");
499 case LOG_INFO:
500 return ("INFO");
501 case LOG_DEBUG:
502 return ("DEBUG");
503 }
504 assert(!"Invalid log level.");
505 abort(); /* XXX: gcc */
506 }
507
508 static int
vsnprlcat(char * str,size_t size,const char * fmt,va_list ap)509 vsnprlcat(char *str, size_t size, const char *fmt, va_list ap)
510 {
511 size_t len;
512
513 len = strlen(str);
514 assert(len < size);
515 return (vsnprintf(str + len, size - len, fmt, ap));
516 }
517
518 static int
snprlcat(char * str,size_t size,const char * fmt,...)519 snprlcat(char *str, size_t size, const char *fmt, ...)
520 {
521 va_list ap;
522 int result;
523
524 va_start(ap, fmt);
525 result = vsnprlcat(str, size, fmt, ap);
526 va_end(ap);
527 return (result);
528 }
529
530 static void
pjdlogv_common_single_line(const char * func,const char * file,int line,int loglevel,int debuglevel,int error,const char * msg)531 pjdlogv_common_single_line(const char *func, const char *file, int line,
532 int loglevel, int debuglevel, int error, const char *msg)
533 {
534 static char log[2 * PJDLOG_MAX_MSGSIZE];
535 char *logp;
536 size_t logs;
537
538 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
539 #ifdef notyet
540 assert(pjdlog_mode == PJDLOG_MODE_STD ||
541 pjdlog_mode == PJDLOG_MODE_SYSLOG ||
542 pjdlog_mode == PJDLOG_MODE_SOCK);
543 #else
544 assert(pjdlog_mode == PJDLOG_MODE_STD ||
545 pjdlog_mode == PJDLOG_MODE_SYSLOG);
546 #endif
547 assert(pjdlog_mode != PJDLOG_MODE_SOCK || pjdlog_sock >= 0);
548 assert(loglevel == LOG_EMERG || loglevel == LOG_ALERT ||
549 loglevel == LOG_CRIT || loglevel == LOG_ERR ||
550 loglevel == LOG_WARNING || loglevel == LOG_NOTICE ||
551 loglevel == LOG_INFO || loglevel == LOG_DEBUG);
552 assert(loglevel != LOG_DEBUG || debuglevel > 0);
553 assert(loglevel != LOG_DEBUG || debuglevel <= pjdlog_debug_level);
554 assert(debuglevel <= 127);
555 assert(error >= -1);
556 assert((file != NULL && line > 0) ||
557 (func == NULL && file == NULL && line == 0));
558
559 switch (pjdlog_mode) {
560 case PJDLOG_MODE_STD:
561 case PJDLOG_MODE_SYSLOG:
562 logp = log;
563 logs = sizeof(log);
564 break;
565 case PJDLOG_MODE_SOCK:
566 logp = log + 4;
567 logs = sizeof(log) - 4;
568 break;
569 default:
570 assert(!"Invalid mode.");
571 }
572
573 *logp = '\0';
574
575 if (pjdlog_mode != PJDLOG_MODE_SOCK) {
576 if (loglevel == LOG_DEBUG) {
577 /* Attach debuglevel if this is debug log. */
578 snprlcat(logp, logs, "[%s%d] ",
579 pjdlog_level_to_string(loglevel), debuglevel);
580 } else {
581 snprlcat(logp, logs, "[%s] ",
582 pjdlog_level_to_string(loglevel));
583 }
584 if (pjdlog_mode != PJDLOG_MODE_SYSLOG &&
585 pjdlog_debug_level >= 1) {
586 snprlcat(logp, logs, "(pid=%d) ", getpid());
587 }
588 }
589 /* Attach file, func, line if debuglevel is 2 or more. */
590 if (pjdlog_debug_level >= 2 && file != NULL) {
591 if (func == NULL)
592 snprlcat(logp, logs, "(%s:%d) ", file, line);
593 else
594 snprlcat(logp, logs, "(%s:%d:%s) ", file, line, func);
595 }
596
597 if (pjdlog_mode != PJDLOG_MODE_SOCK) {
598 snprlcat(logp, logs, "%s",
599 pjdlog_prefix[pjdlog_prefix_current]);
600 }
601
602 strlcat(logp, msg, logs);
603
604 /* Attach error description. */
605 if (error != -1)
606 snprlcat(logp, logs, ": %s.", strerror(error));
607
608 switch (pjdlog_mode) {
609 case PJDLOG_MODE_STD:
610 fprintf(stderr, "%s\n", logp);
611 fflush(stderr);
612 break;
613 case PJDLOG_MODE_SYSLOG:
614 syslog(loglevel, "%s", logp);
615 break;
616 #ifdef notyet
617 case PJDLOG_MODE_SOCK:
618 {
619 char ack[2];
620 uint16_t dlen;
621
622 log[2] = loglevel;
623 log[3] = debuglevel;
624 dlen = strlen(logp) + 3; /* +3 = loglevel, debuglevel and terminating \0 */
625 bcopy(&dlen, log, sizeof(dlen));
626 if (robust_send(pjdlog_sock, log, (size_t)dlen + 2) == -1) /* +2 for size */
627 assert(!"Unable to send log.");
628 if (robust_recv(pjdlog_sock, ack, sizeof(ack)) == -1)
629 assert(!"Unable to send log.");
630 break;
631 }
632 #endif
633 default:
634 assert(!"Invalid mode.");
635 }
636 }
637
638 /*
639 * Common log routine, which can handle regular log level as well as debug
640 * level. We decide here where to send the logs (stdout/stderr or syslog).
641 */
642 void
_pjdlogv_common(const char * func,const char * file,int line,int loglevel,int debuglevel,int error,const char * fmt,va_list ap)643 _pjdlogv_common(const char *func, const char *file, int line, int loglevel,
644 int debuglevel, int error, const char *fmt, va_list ap)
645 {
646 char log[PJDLOG_MAX_MSGSIZE];
647 char *logp, *curline;
648 const char *prvline;
649 int saved_errno;
650
651 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
652 assert(pjdlog_mode == PJDLOG_MODE_STD ||
653 pjdlog_mode == PJDLOG_MODE_SYSLOG ||
654 pjdlog_mode == PJDLOG_MODE_SOCK);
655 assert(pjdlog_mode != PJDLOG_MODE_SOCK || pjdlog_sock >= 0);
656 assert(loglevel == LOG_EMERG || loglevel == LOG_ALERT ||
657 loglevel == LOG_CRIT || loglevel == LOG_ERR ||
658 loglevel == LOG_WARNING || loglevel == LOG_NOTICE ||
659 loglevel == LOG_INFO || loglevel == LOG_DEBUG);
660 assert(loglevel != LOG_DEBUG || debuglevel > 0);
661 assert(debuglevel <= 127);
662 assert(error >= -1);
663
664 /* Ignore debug above configured level. */
665 if (loglevel == LOG_DEBUG && debuglevel > pjdlog_debug_level)
666 return;
667
668 saved_errno = errno;
669
670 vsnprintf(log, sizeof(log), fmt, ap);
671 logp = log;
672 prvline = NULL;
673
674 while ((curline = strsep(&logp, "\n")) != NULL) {
675 if (*curline == '\0')
676 continue;
677 if (prvline != NULL) {
678 pjdlogv_common_single_line(func, file, line, loglevel,
679 debuglevel, -1, prvline);
680 }
681 prvline = curline;
682 }
683 if (prvline == NULL)
684 prvline = "";
685 pjdlogv_common_single_line(func, file, line, loglevel, debuglevel,
686 error, prvline);
687
688 errno = saved_errno;
689 }
690
691 /*
692 * Common log routine.
693 */
694 void
_pjdlog_common(const char * func,const char * file,int line,int loglevel,int debuglevel,int error,const char * fmt,...)695 _pjdlog_common(const char *func, const char *file, int line, int loglevel,
696 int debuglevel, int error, const char *fmt, ...)
697 {
698 va_list ap;
699
700 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
701
702 va_start(ap, fmt);
703 _pjdlogv_common(func, file, line, loglevel, debuglevel, error, fmt, ap);
704 va_end(ap);
705 }
706
707 /*
708 * Log error, errno and exit.
709 */
710 void
_pjdlogv_exit(const char * func,const char * file,int line,int exitcode,int error,const char * fmt,va_list ap)711 _pjdlogv_exit(const char *func, const char *file, int line, int exitcode,
712 int error, const char *fmt, va_list ap)
713 {
714
715 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
716
717 _pjdlogv_common(func, file, line, exitcode == 0 ? LOG_INFO : LOG_ERR, 0,
718 error, fmt, ap);
719 exit(exitcode);
720 /* NOTREACHED */
721 }
722
723 /*
724 * Log error, errno and exit.
725 */
726 void
_pjdlog_exit(const char * func,const char * file,int line,int exitcode,int error,const char * fmt,...)727 _pjdlog_exit(const char *func, const char *file, int line, int exitcode,
728 int error, const char *fmt, ...)
729 {
730 va_list ap;
731
732 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
733
734 va_start(ap, fmt);
735 _pjdlogv_exit(func, file, line, exitcode, error, fmt, ap);
736 /* NOTREACHED */
737 va_end(ap);
738 }
739
740 /*
741 * Log failure message and exit.
742 */
743 void
_pjdlog_abort(const char * func,const char * file,int line,int error,const char * failedexpr,const char * fmt,...)744 _pjdlog_abort(const char *func, const char *file, int line,
745 int error, const char *failedexpr, const char *fmt, ...)
746 {
747 va_list ap;
748
749 assert(pjdlog_initialized == PJDLOG_INITIALIZED);
750
751 /*
752 * Set pjdlog_debug_level to 2, so that file, line and func are
753 * included in log. This is fine as we will exit anyway.
754 */
755 if (pjdlog_debug_level < 2)
756 pjdlog_debug_level = 2;
757
758 /*
759 * When there is no message we pass __func__ as 'fmt'.
760 * It would be cleaner to pass NULL or "", but gcc generates a warning
761 * for both of those.
762 */
763 if (fmt != func) {
764 va_start(ap, fmt);
765 _pjdlogv_common(func, file, line, LOG_CRIT, 0, -1, fmt, ap);
766 va_end(ap);
767 }
768 if (failedexpr == NULL) {
769 _pjdlog_common(func, file, line, LOG_CRIT, 0, -1, "Aborted.");
770 } else {
771 _pjdlog_common(func, file, line, LOG_CRIT, 0, -1,
772 "Assertion failed: (%s).", failedexpr);
773 }
774 if (error != -1)
775 _pjdlog_common(func, file, line, LOG_CRIT, 0, error, "Errno");
776 abort();
777 }
778
779 #ifdef notyet
780 /*
781 * Receive log from the given socket.
782 */
783 int
pjdlog_receive(int sock)784 pjdlog_receive(int sock)
785 {
786 char log[PJDLOG_MAX_MSGSIZE];
787 int loglevel, debuglevel;
788 uint16_t dlen;
789
790 if (robust_recv(sock, &dlen, sizeof(dlen)) == -1)
791 return (-1);
792
793 PJDLOG_ASSERT(dlen > 0);
794 PJDLOG_ASSERT(dlen <= PJDLOG_MAX_MSGSIZE - 3);
795
796 if (robust_recv(sock, log, (size_t)dlen) == -1)
797 return (-1);
798
799 log[dlen - 1] = '\0';
800 loglevel = log[0];
801 debuglevel = log[1];
802 _pjdlog_common(NULL, NULL, 0, loglevel, debuglevel, -1, "%s", log + 2);
803
804 if (robust_send(sock, "ok", 2) == -1)
805 return (-1);
806
807 return (0);
808 }
809 #endif
810