lib/libpjdlog/pjdlog.c

   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
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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 *
 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
 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
 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
 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 *
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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