common/logging.c

   1 /* logging.c - Useful logging functions
   2  * Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
   3  *               2009, 2010 Free Software Foundation, Inc.
   4  *
   5  * This file is part of JNLIB, which is a subsystem of GnuPG.
   6  *
   7  * JNLIB is free software; you can redistribute it and/or modify it
   8  * under the terms of either
   9  *
  10  *   - the GNU Lesser General Public License as published by the Free
  11  *     Software Foundation; either version 3 of the License, or (at
  12  *     your option) any later version.
  13  *
  14  * or
  15  *
  16  *   - the GNU General Public License as published by the Free
  17  *     Software Foundation; either version 2 of the License, or (at
  18  *     your option) any later version.
  19  *
  20  * or both in parallel, as here.
  21  *
  22  * JNLIB is distributed in the hope that it will be useful, but
  23  * WITHOUT ANY WARRANTY; without even the implied warranty of
  24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  25  * General Public License for more details.
  26  *
  27  * You should have received a copies of the GNU General Public License
  28  * and the GNU Lesser General Public License along with this program;
  29  * if not, see <http://www.gnu.org/licenses/>.
  30  */
  31
  32
  33 #include <config.h>
  34 #include <stdlib.h>
  35 #include <stdio.h>
  36 #include <string.h>
  37 #include <stdarg.h>
  38 #include <stddef.h>
  39 #include <errno.h>
  40 #include <time.h>
  41 #include <sys/types.h>
  42 #include <sys/stat.h>
  43 #ifdef HAVE_W32_SYSTEM
  44 # ifdef HAVE_WINSOCK2_H
  45 #  include <winsock2.h>
  46 # endif
  47 # include <windows.h>
  48 #else /*!HAVE_W32_SYSTEM*/
  49 # include <sys/socket.h>
  50 # include <sys/un.h>
  51 # include <netinet/in.h>
  52 # include <arpa/inet.h>
  53 #endif /*!HAVE_W32_SYSTEM*/
  54 #include <unistd.h>
  55 #include <fcntl.h>
  56 #include <assert.h>
  57
  58
  59 #define JNLIB_NEED_LOG_LOGV 1
  60 #define JNLIB_NEED_AFLOCAL 1
  61 #include "libjnlib-config.h"
  62 #include "logging.h"
  63
  64 #ifdef HAVE_W32_SYSTEM
  65 # define S_IRGRP S_IRUSR
  66 # define S_IROTH S_IRUSR
  67 # define S_IWGRP S_IWUSR
  68 # define S_IWOTH S_IWUSR
  69 #endif
  70
  71
  72 #ifdef HAVE_W32CE_SYSTEM
  73 # define isatty(a)  (0)
  74 #endif
  75
  76 #undef WITH_IPV6
  77 #if defined (AF_INET6) && defined(PF_INET) \
  78     && defined (INET6_ADDRSTRLEN) && defined(HAVE_INET_PTON)
  79 # define WITH_IPV6 1
  80 #endif
  81
  82 #ifndef EAFNOSUPPORT
  83 # define EAFNOSUPPORT EINVAL
  84 #endif
  85 #ifndef INADDR_NONE  /* Slowaris is missing that.  */
  86 #define INADDR_NONE  ((unsigned long)(-1))
  87 #endif /*INADDR_NONE*/
  88
  89 #ifdef HAVE_W32_SYSTEM
  90 #define sock_close(a)  closesocket(a)
  91 #else
  92 #define sock_close(a)  close(a)
  93 #endif
  94
  95
  96 static estream_t logstream;
  97 static int log_socket = -1;
  98 static char prefix_buffer[80];
  99 static int with_time;
 100 static int with_prefix;
 101 static int with_pid;
 102 #ifdef HAVE_W32_SYSTEM
 103 static int no_registry;
 104 #endif
 105 static int (*get_pid_suffix_cb)(unsigned long *r_value);
 106 static int running_detached;
 107 static int force_prefixes;
 108
 109 static int missing_lf;
 110 static int errorcount;
 111
 112
 113 int
 114 log_get_errorcount (int clear)
 115 {
 116     int n = errorcount;
 117     if( clear )
 118         errorcount = 0;
 119     return n;
 120 }
 121
 122 void
 123 log_inc_errorcount (void)
 124 {
 125    errorcount++;
 126 }
 127
 128
 129 /* The following 3 functions are used by es_fopencookie to write logs
 130    to a socket.  */
 131 struct fun_cookie_s
 132 {
 133   int fd;
 134   int quiet;
 135   int want_socket;
 136   int is_socket;
 137 #ifdef HAVE_W32CE_SYSTEM
 138   int use_writefile;
 139 #endif
 140   char name[1];
 141 };
 142
 143
 144 /* Write NBYTES of BUFFER to file descriptor FD. */
 145 static int
 146 writen (int fd, const void *buffer, size_t nbytes, int is_socket)
 147 {
 148   const char *buf = buffer;
 149   size_t nleft = nbytes;
 150   int nwritten;
 151 #ifndef HAVE_W32_SYSTEM
 152   (void)is_socket; /* Not required.  */
 153 #endif
 154
 155   while (nleft > 0)
 156     {
 157 #ifdef HAVE_W32_SYSTEM
 158       if (is_socket)
 159         nwritten = send (fd, buf, nleft, 0);
 160       else
 161 #endif
 162         nwritten = write (fd, buf, nleft);
 163
 164       if (nwritten < 0 && errno == EINTR)
 165         continue;
 166       if (nwritten < 0)
 167         return -1;
 168       nleft -= nwritten;
 169       buf = buf + nwritten;
 170     }
 171
 172   return 0;
 173 }
 174
 175
 176 /* Returns true if STR represents a valid port number in decimal
 177    notation and no garbage is following.  */
 178 static int
 179 parse_portno (const char *str, unsigned short *r_port)
 180 {
 181   unsigned int value;
 182
 183   for (value=0; *str && (*str >= '0' && *str <= '9'); str++)
 184     {
 185       value = value * 10 + (*str - '0');
 186       if (value > 65535)
 187         return 0;
 188     }
 189   if (*str || !value)
 190     return 0;
 191
 192   *r_port = value;
 193   return 1;
 194 }
 195
 196
 197 static ssize_t
 198 fun_writer (void *cookie_arg, const void *buffer, size_t size)
 199 {
 200   struct fun_cookie_s *cookie = cookie_arg;
 201
 202   /* FIXME: Use only estream with a callback for socket writing.  This
 203      avoids the ugly mix of fd and estream code.  */
 204
 205   /* Note that we always try to reconnect to the socket but print
 206      error messages only the first time an error occured.  If
 207      RUNNING_DETACHED is set we don't fall back to stderr and even do
 208      not print any error messages.  This is needed because detached
 209      processes often close stderr and by writing to file descriptor 2
 210      we might send the log message to a file not intended for logging
 211      (e.g. a pipe or network connection). */
 212   if (cookie->want_socket && cookie->fd == -1)
 213     {
 214 #ifdef WITH_IPV6
 215       struct sockaddr_in6 srvr_addr_in6;
 216 #endif
 217       struct sockaddr_in srvr_addr_in;
 218 #ifndef HAVE_W32_SYSTEM
 219       struct sockaddr_un srvr_addr_un;
 220 #endif
 221       size_t addrlen;
 222       struct sockaddr *srvr_addr = NULL;
 223       unsigned short port = 0;
 224       int af = AF_LOCAL;
 225       int pf = PF_LOCAL;
 226       const char *name = cookie->name;
 227
 228       /* Not yet open or meanwhile closed due to an error. */
 229       cookie->is_socket = 0;
 230
 231       /* Check whether this is a TCP socket or a local socket.  */
 232       if (!strncmp (name, "tcp://", 6) && name[6])
 233         {
 234           name += 6;
 235           af = AF_INET;
 236           pf = PF_INET;
 237         }
 238 #ifndef HAVE_W32_SYSTEM
 239       else if (!strncmp (name, "socket://", 9) && name[9])
 240         name += 9;
 241 #endif
 242
 243       if (af == AF_LOCAL)
 244         {
 245 #ifdef HAVE_W32_SYSTEM
 246           addrlen = 0;
 247 #else
 248           memset (&srvr_addr, 0, sizeof srvr_addr);
 249           srvr_addr_un.sun_family = af;
 250           strncpy (srvr_addr_un.sun_path,
 251                    name, sizeof (srvr_addr_un.sun_path)-1);
 252           srvr_addr_un.sun_path[sizeof (srvr_addr_un.sun_path)-1] = 0;
 253           srvr_addr = (struct sockaddr *)&srvr_addr_un;
 254           addrlen = SUN_LEN (&srvr_addr_un);
 255 #endif
 256         }
 257       else
 258         {
 259           char *addrstr, *p;
 260 #ifdef HAVE_INET_PTON
 261           void *addrbuf = NULL;
 262 #endif /*HAVE_INET_PTON*/
 263
 264           addrstr = jnlib_malloc (strlen (name) + 1);
 265           if (!addrstr)
 266             addrlen = 0; /* This indicates an error.  */
 267           else if (*name == '[')
 268             {
 269               /* Check for IPv6 literal address.  */
 270               strcpy (addrstr, name+1);
 271               p = strchr (addrstr, ']');
 272               if (!p || p[1] != ':' || !parse_portno (p+2, &port))
 273                 {
 274                   jnlib_set_errno (EINVAL);
 275                   addrlen = 0;
 276                 }
 277               else
 278                 {
 279                   *p = 0;
 280 #ifdef WITH_IPV6
 281                   af = AF_INET6;
 282                   pf = PF_INET6;
 283                   memset (&srvr_addr_in6, 0, sizeof srvr_addr_in6);
 284                   srvr_addr_in6.sin6_family = af;
 285                   srvr_addr_in6.sin6_port = htons (port);
 286 #ifdef HAVE_INET_PTON
 287                   addrbuf = &srvr_addr_in6.sin6_addr;
 288 #endif /*HAVE_INET_PTON*/
 289                   srvr_addr = (struct sockaddr *)&srvr_addr_in6;
 290                   addrlen = sizeof srvr_addr_in6;
 291 #else
 292                   jnlib_set_errno (EAFNOSUPPORT);
 293                   addrlen = 0;
 294 #endif
 295                 }
 296             }
 297           else
 298             {
 299               /* Check for IPv4 literal address.  */
 300               strcpy (addrstr, name);
 301               p = strchr (addrstr, ':');
 302               if (!p || !parse_portno (p+1, &port))
 303                 {
 304                   jnlib_set_errno (EINVAL);
 305                   addrlen = 0;
 306                 }
 307               else
 308                 {
 309                   *p = 0;
 310                   memset (&srvr_addr_in, 0, sizeof srvr_addr_in);
 311                   srvr_addr_in.sin_family = af;
 312                   srvr_addr_in.sin_port = htons (port);
 313 #ifdef HAVE_INET_PTON
 314                   addrbuf = &srvr_addr_in.sin_addr;
 315 #endif /*HAVE_INET_PTON*/
 316                   srvr_addr = (struct sockaddr *)&srvr_addr_in;
 317                   addrlen = sizeof srvr_addr_in;
 318                 }
 319             }
 320
 321           if (addrlen)
 322             {
 323 #ifdef HAVE_INET_PTON
 324               if (inet_pton (af, addrstr, addrbuf) != 1)
 325                 addrlen = 0;
 326 #else /*!HAVE_INET_PTON*/
 327               /* We need to use the old function.  If we are here v6
 328                  support isn't enabled anyway and thus we can do fine
 329                  without.  Note that Windows has a compatible inet_pton
 330                  function named inetPton, but only since Vista.  */
 331               srvr_addr_in.sin_addr.s_addr = inet_addr (addrstr);
 332               if (srvr_addr_in.sin_addr.s_addr == INADDR_NONE)
 333                 addrlen = 0;
 334 #endif /*!HAVE_INET_PTON*/
 335             }
 336
 337           jnlib_free (addrstr);
 338         }
 339
 340       cookie->fd = addrlen? socket (pf, SOCK_STREAM, 0) : -1;
 341       if (cookie->fd == -1)
 342         {
 343           if (!cookie->quiet && !running_detached
 344               && isatty (es_fileno (es_stderr)))
 345             es_fprintf (es_stderr, "failed to create socket for logging: %s\n",
 346                         strerror(errno));
 347         }
 348       else
 349         {
 350           if (connect (cookie->fd, srvr_addr, addrlen) == -1)
 351             {
 352               if (!cookie->quiet && !running_detached
 353                   && isatty (es_fileno (es_stderr)))
 354                 es_fprintf (es_stderr, "can't connect to '%s': %s\n",
 355                             cookie->name, strerror(errno));
 356               sock_close (cookie->fd);
 357               cookie->fd = -1;
 358             }
 359         }
 360
 361       if (cookie->fd == -1)
 362         {
 363           if (!running_detached)
 364             {
 365               /* Due to all the problems with apps not running
 366                  detached but being called with stderr closed or used
 367                  for a different purposes, it does not make sense to
 368                  switch to stderr.  We therefore disable it. */
 369               if (!cookie->quiet)
 370                 {
 371                   /* fputs ("switching logging to stderr\n", stderr);*/
 372                   cookie->quiet = 1;
 373                 }
 374               cookie->fd = -1; /*fileno (stderr);*/
 375             }
 376         }
 377       else /* Connection has been established. */
 378         {
 379           cookie->quiet = 0;
 380           cookie->is_socket = 1;
 381         }
 382     }
 383
 384   log_socket = cookie->fd;
 385   if (cookie->fd != -1)
 386     {
 387 #ifdef HAVE_W32CE_SYSTEM
 388       if (cookie->use_writefile)
 389         {
 390           DWORD nwritten;
 391
 392           WriteFile ((HANDLE)cookie->fd, buffer, size, &nwritten, NULL);
 393           return (ssize_t)size; /* Okay.  */
 394         }
 395 #endif
 396       if (!writen (cookie->fd, buffer, size, cookie->is_socket))
 397         return (ssize_t)size; /* Okay. */
 398     }
 399
 400   if (!running_detached && cookie->fd != -1
 401       && isatty (es_fileno (es_stderr)))
 402     {
 403       if (*cookie->name)
 404         es_fprintf (es_stderr, "error writing to '%s': %s\n",
 405                     cookie->name, strerror(errno));
 406       else
 407         es_fprintf (es_stderr, "error writing to file descriptor %d: %s\n",
 408                     cookie->fd, strerror(errno));
 409     }
 410   if (cookie->is_socket && cookie->fd != -1)
 411     {
 412       sock_close (cookie->fd);
 413       cookie->fd = -1;
 414       log_socket = -1;
 415     }
 416
 417   return (ssize_t)size;
 418 }
 419
 420
 421 static int
 422 fun_closer (void *cookie_arg)
 423 {
 424   struct fun_cookie_s *cookie = cookie_arg;
 425
 426   if (cookie->fd != -1 && cookie->fd != 2)
 427     sock_close (cookie->fd);
 428   jnlib_free (cookie);
 429   log_socket = -1;
 430   return 0;
 431 }
 432
 433
 434 /* Common function to either set the logging to a file or a file
 435    descriptor. */
 436 static void
 437 set_file_fd (const char *name, int fd)
 438 {
 439   estream_t fp;
 440   int want_socket;
 441 #ifdef HAVE_W32CE_SYSTEM
 442   int use_writefile = 0;
 443 #endif
 444   struct fun_cookie_s *cookie;
 445
 446   /* Close an open log stream.  */
 447   if (logstream)
 448     {
 449       es_fclose (logstream);
 450       logstream = NULL;
 451     }
 452
 453   /* Figure out what kind of logging we want.  */
 454   if (name && !strcmp (name, "-"))
 455     {
 456       name = NULL;
 457       fd = es_fileno (es_stderr);
 458     }
 459
 460   want_socket = 0;
 461   if (name && !strncmp (name, "tcp://", 6) && name[6])
 462     want_socket = 1;
 463 #ifndef HAVE_W32_SYSTEM
 464   else if (name && !strncmp (name, "socket://", 9) && name[9])
 465     want_socket = 2;
 466 #endif /*HAVE_W32_SYSTEM*/
 467 #ifdef HAVE_W32CE_SYSTEM
 468   else if (name && !strcmp (name, "GPG2:"))
 469     {
 470       HANDLE hd;
 471
 472       ActivateDevice (L"Drivers\\"GNUPG_NAME"_Log", 0);
 473       /* Ignore a filename and write the debug output to the GPG2:
 474          device.  */
 475       hd = CreateFile (L"GPG2:", GENERIC_WRITE,
 476                        FILE_SHARE_READ | FILE_SHARE_WRITE,
 477                        NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 478       fd = (hd == INVALID_HANDLE_VALUE)? -1 : (int)hd;
 479       name = NULL;
 480       force_prefixes = 1;
 481       use_writefile = 1;
 482     }
 483 #endif /*HAVE_W32CE_SYSTEM*/
 484
 485   /* Setup a new stream.  */
 486
 487   /* The xmalloc below is justified because we can expect that this
 488      function is called only during initialization and there is no
 489      easy way out of this error condition.  */
 490   cookie = jnlib_xmalloc (sizeof *cookie + (name? strlen (name):0));
 491   strcpy (cookie->name, name? name:"");
 492   cookie->quiet = 0;
 493   cookie->is_socket = 0;
 494   cookie->want_socket = want_socket;
 495 #ifdef HAVE_W32CE_SYSTEM
 496   cookie->use_writefile = use_writefile;
 497 #endif
 498   if (!name)
 499     cookie->fd = fd;
 500   else if (want_socket)
 501     cookie->fd = -1;
 502   else
 503     {
 504       do
 505         cookie->fd = open (name, O_WRONLY|O_APPEND|O_CREAT,
 506                            (S_IRUSR|S_IRGRP|S_IROTH|S_IWUSR|S_IWGRP|S_IWOTH));
 507       while (cookie->fd == -1 && errno == EINTR);
 508     }
 509   log_socket = cookie->fd;
 510
 511   {
 512     es_cookie_io_functions_t io = { NULL };
 513     io.func_write = fun_writer;
 514     io.func_close = fun_closer;
 515
 516     fp = es_fopencookie (cookie, "w", io);
 517   }
 518
 519   /* On error default to a stderr based estream.  */
 520   if (!fp)
 521     fp = es_stderr;
 522
 523   es_setvbuf (fp, NULL, _IOLBF, 0);
 524
 525   logstream = fp;
 526
 527   /* We always need to print the prefix and the pid for socket mode,
 528      so that the server reading the socket can do something
 529      meaningful. */
 530   force_prefixes = want_socket;
 531
 532   missing_lf = 0;
 533 }
 534
 535
 536 /* Set the file to write log to.  The special names NULL and "-" may
 537    be used to select stderr and names formatted like
 538    "socket:///home/foo/mylogs" may be used to write the logging to the
 539    socket "/home/foo/mylogs".  If the connection to the socket fails
 540    or a write error is detected, the function writes to stderr and
 541    tries the next time again to connect the socket.
 542   */
 543 void
 544 log_set_file (const char *name)
 545 {
 546   set_file_fd (name? name: "-", -1);
 547 }
 548
 549 void
 550 log_set_fd (int fd)
 551 {
 552   set_file_fd (NULL, fd);
 553 }
 554
 555
 556 void
 557 log_set_pid_suffix_cb (int (*cb)(unsigned long *r_value))
 558 {
 559   get_pid_suffix_cb = cb;
 560 }
 561
 562
 563 void
 564 log_set_prefix (const char *text, unsigned int flags)
 565 {
 566   if (text)
 567     {
 568       strncpy (prefix_buffer, text, sizeof (prefix_buffer)-1);
 569       prefix_buffer[sizeof (prefix_buffer)-1] = 0;
 570     }
 571
 572   with_prefix = (flags & JNLIB_LOG_WITH_PREFIX);
 573   with_time = (flags & JNLIB_LOG_WITH_TIME);
 574   with_pid  = (flags & JNLIB_LOG_WITH_PID);
 575   running_detached = (flags & JNLIB_LOG_RUN_DETACHED);
 576 #ifdef HAVE_W32_SYSTEM
 577   no_registry = (flags & JNLIB_LOG_NO_REGISTRY);
 578 #endif
 579 }
 580
 581
 582 const char *
 583 log_get_prefix (unsigned int *flags)
 584 {
 585   if (flags)
 586     {
 587       *flags = 0;
 588       if (with_prefix)
 589         *flags |= JNLIB_LOG_WITH_PREFIX;
 590       if (with_time)
 591         *flags |= JNLIB_LOG_WITH_TIME;
 592       if (with_pid)
 593         *flags |= JNLIB_LOG_WITH_PID;
 594       if (running_detached)
 595         *flags |= JNLIB_LOG_RUN_DETACHED;
 596 #ifdef HAVE_W32_SYSTEM
 597       if (no_registry)
 598         *flags |= JNLIB_LOG_NO_REGISTRY;
 599 #endif
 600     }
 601   return prefix_buffer;
 602 }
 603
 604 /* This function returns true if the file descriptor FD is in use for
 605    logging.  This is preferable over a test using log_get_fd in that
 606    it allows the logging code to use more then one file descriptor.  */
 607 int
 608 log_test_fd (int fd)
 609 {
 610   if (logstream)
 611     {
 612       int tmp = es_fileno (logstream);
 613       if ( tmp != -1 && tmp == fd)
 614         return 1;
 615     }
 616   if (log_socket != -1 && log_socket == fd)
 617     return 1;
 618   return 0;
 619 }
 620
 621 int
 622 log_get_fd ()
 623 {
 624   return logstream? es_fileno(logstream) : -1;
 625 }
 626
 627 estream_t
 628 log_get_stream ()
 629 {
 630   if (!logstream)
 631     {
 632       log_set_file (NULL); /* Make sure a log stream has been set.  */
 633       assert (logstream);
 634     }
 635   return logstream;
 636 }
 637
 638 static void
 639 do_logv (int level, int ignore_arg_ptr, const char *fmt, va_list arg_ptr)
 640 {
 641   if (!logstream)
 642     {
 643 #ifdef HAVE_W32_SYSTEM
 644       char *tmp;
 645
 646       tmp = (no_registry
 647              ? NULL
 648              : read_w32_registry_string (NULL, GNUPG_REGISTRY_DIR,
 649                                          "DefaultLogFile"));
 650       log_set_file (tmp && *tmp? tmp : NULL);
 651       jnlib_free (tmp);
 652 #else
 653       log_set_file (NULL); /* Make sure a log stream has been set.  */
 654 #endif
 655       assert (logstream);
 656     }
 657
 658   es_flockfile (logstream);
 659   if (missing_lf && level != JNLIB_LOG_CONT)
 660     es_putc_unlocked ('\n', logstream );
 661   missing_lf = 0;
 662
 663   if (level != JNLIB_LOG_CONT)
 664     { /* Note this does not work for multiple line logging as we would
 665        * need to print to a buffer first */
 666       if (with_time && !force_prefixes)
 667         {
 668           struct tm *tp;
 669           time_t atime = time (NULL);
 670
 671           tp = localtime (&atime);
 672           es_fprintf_unlocked (logstream, "%04d-%02d-%02d %02d:%02d:%02d ",
 673                                1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday,
 674                                tp->tm_hour, tp->tm_min, tp->tm_sec );
 675         }
 676       if (with_prefix || force_prefixes)
 677         es_fputs_unlocked (prefix_buffer, logstream);
 678       if (with_pid || force_prefixes)
 679         {
 680           unsigned long pidsuf;
 681           int pidfmt;
 682
 683           if (get_pid_suffix_cb && (pidfmt=get_pid_suffix_cb (&pidsuf)))
 684             es_fprintf_unlocked (logstream, pidfmt == 1? "[%u.%lu]":"[%u.%lx]",
 685                                  (unsigned int)getpid (), pidsuf);
 686           else
 687             es_fprintf_unlocked (logstream, "[%u]", (unsigned int)getpid ());
 688         }
 689       if (!with_time || force_prefixes)
 690         es_putc_unlocked (':', logstream);
 691       /* A leading backspace suppresses the extra space so that we can
 692          correctly output, programname, filename and linenumber. */
 693       if (fmt && *fmt == '\b')
 694         fmt++;
 695       else
 696         es_putc_unlocked (' ', logstream);
 697     }
 698
 699   switch (level)
 700     {
 701     case JNLIB_LOG_BEGIN: break;
 702     case JNLIB_LOG_CONT: break;
 703     case JNLIB_LOG_INFO: break;
 704     case JNLIB_LOG_WARN: break;
 705     case JNLIB_LOG_ERROR: break;
 706     case JNLIB_LOG_FATAL: es_fputs_unlocked ("Fatal: ",logstream ); break;
 707     case JNLIB_LOG_BUG:   es_fputs_unlocked ("Ohhhh jeeee: ", logstream); break;
 708     case JNLIB_LOG_DEBUG: es_fputs_unlocked ("DBG: ", logstream ); break;
 709     default:
 710       es_fprintf_unlocked (logstream,"[Unknown log level %d]: ", level);
 711       break;
 712     }
 713
 714   if (fmt)
 715     {
 716       if (ignore_arg_ptr)
 717         es_fputs_unlocked (fmt, logstream);
 718       else
 719         es_vfprintf_unlocked (logstream, fmt, arg_ptr);
 720       if (*fmt && fmt[strlen(fmt)-1] != '\n')
 721         missing_lf = 1;
 722     }
 723
 724   if (level == JNLIB_LOG_FATAL)
 725     {
 726       if (missing_lf)
 727         es_putc_unlocked ('\n', logstream);
 728       es_funlockfile (logstream);
 729       exit (2);
 730     }
 731   else if (level == JNLIB_LOG_BUG)
 732     {
 733       if (missing_lf)
 734         es_putc_unlocked ('\n', logstream );
 735       es_funlockfile (logstream);
 736       abort ();
 737     }
 738   else
 739     es_funlockfile (logstream);
 740 }
 741
 742
 743 void
 744 log_log (int level, const char *fmt, ...)
 745 {
 746   va_list arg_ptr ;
 747
 748   va_start (arg_ptr, fmt) ;
 749   do_logv (level, 0, fmt, arg_ptr);
 750   va_end (arg_ptr);
 751 }
 752
 753
 754 void
 755 log_logv (int level, const char *fmt, va_list arg_ptr)
 756 {
 757   do_logv (level, 0, fmt, arg_ptr);
 758 }
 759
 760
 761 static void
 762 do_log_ignore_arg (int level, const char *str, ...)
 763 {
 764   va_list arg_ptr;
 765   va_start (arg_ptr, str);
 766   do_logv (level, 1, str, arg_ptr);
 767   va_end (arg_ptr);
 768 }
 769
 770
 771 void
 772 log_string (int level, const char *string)
 773 {
 774   /* We need a dummy arg_ptr, but there is no portable way to create
 775      one.  So we call the do_logv function through a variadic wrapper.
 776      MB: Why not just use "%s"?  */
 777   do_log_ignore_arg (level, string);
 778 }
 779
 780
 781 void
 782 log_info (const char *fmt, ...)
 783 {
 784   va_list arg_ptr ;
 785
 786   va_start (arg_ptr, fmt);
 787   do_logv (JNLIB_LOG_INFO, 0, fmt, arg_ptr);
 788   va_end (arg_ptr);
 789 }
 790
 791
 792 void
 793 log_error (const char *fmt, ...)
 794 {
 795   va_list arg_ptr ;
 796
 797   va_start (arg_ptr, fmt);
 798   do_logv (JNLIB_LOG_ERROR, 0, fmt, arg_ptr);
 799   va_end (arg_ptr);
 800   /* Protect against counter overflow.  */
 801   if (errorcount < 30000)
 802     errorcount++;
 803 }
 804
 805
 806 void
 807 log_fatal (const char *fmt, ...)
 808 {
 809   va_list arg_ptr ;
 810
 811   va_start (arg_ptr, fmt);
 812   do_logv (JNLIB_LOG_FATAL, 0, fmt, arg_ptr);
 813   va_end (arg_ptr);
 814   abort (); /* Never called; just to make the compiler happy.  */
 815 }
 816
 817
 818 void
 819 log_bug (const char *fmt, ...)
 820 {
 821   va_list arg_ptr ;
 822
 823   va_start (arg_ptr, fmt);
 824   do_logv (JNLIB_LOG_BUG, 0, fmt, arg_ptr);
 825   va_end (arg_ptr);
 826   abort (); /* Never called; just to make the compiler happy.  */
 827 }
 828
 829
 830 void
 831 log_debug (const char *fmt, ...)
 832 {
 833   va_list arg_ptr ;
 834
 835   va_start (arg_ptr, fmt);
 836   do_logv (JNLIB_LOG_DEBUG, 0, fmt, arg_ptr);
 837   va_end (arg_ptr);
 838 }
 839
 840
 841 void
 842 log_printf (const char *fmt, ...)
 843 {
 844   va_list arg_ptr;
 845
 846   va_start (arg_ptr, fmt);
 847   do_logv (fmt ? JNLIB_LOG_CONT : JNLIB_LOG_BEGIN, 0, fmt, arg_ptr);
 848   va_end (arg_ptr);
 849 }
 850
 851
 852 /* Flush the log - this is useful to make sure that the trailing
 853    linefeed has been printed.  */
 854 void
 855 log_flush (void)
 856 {
 857   do_log_ignore_arg (JNLIB_LOG_CONT, NULL);
 858 }
 859
 860
 861 /* Print a hexdump of BUFFER.  With TEXT of NULL print just the raw
 862    dump, with TEXT just an empty string, print a trailing linefeed,
 863    otherwise print an entire debug line. */
 864 void
 865 log_printhex (const char *text, const void *buffer, size_t length)
 866 {
 867   if (text && *text)
 868     log_debug ("%s ", text);
 869   if (length)
 870     {
 871       const unsigned char *p = buffer;
 872       log_printf ("%02X", *p);
 873       for (length--, p++; length--; p++)
 874         log_printf (" %02X", *p);
 875     }
 876   if (text)
 877     log_printf ("\n");
 878 }
 879
 880
 881 /*
 882 void
 883 log_printcanon () {}
 884 is found in sexputils.c
 885 */
 886
 887 /*
 888 void
 889 log_printsexp () {}
 890 is found in sexputils.c
 891 */
 892
 893
 894 void
 895 log_clock (const char *string)
 896 {
 897 #if 0
 898   static unsigned long long initial;
 899   struct timespec tv;
 900   unsigned long long now;
 901
 902   if (clock_gettime (CLOCK_REALTIME, &tv))
 903     {
 904       log_debug ("error getting the realtime clock value\n");
 905       return;
 906     }
 907   now = tv.tv_sec * 1000000000ull;
 908   now += tv.tv_nsec;
 909
 910   if (!initial)
 911     initial = now;
 912
 913   log_debug ("[%6llu] %s", (now - initial)/1000, string);
 914 #else
 915   /* You need to link with -ltr to enable the above code.  */
 916   log_debug ("[not enabled in the source] %s", string);
 917 #endif
 918 }
 919
 920
 921 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 )
 922 void
 923 bug_at( const char *file, int line, const char *func )
 924 {
 925   log_log (JNLIB_LOG_BUG, ("... this is a bug (%s:%d:%s)\n"), file, line, func);
 926   abort (); /* Never called; just to make the compiler happy.  */
 927 }
 928 #else
 929 void
 930 bug_at( const char *file, int line )
 931 {
 932   log_log (JNLIB_LOG_BUG, _("you found a bug ... (%s:%d)\n"), file, line);
 933   abort (); /* Never called; just to make the compiler happy.  */
 934 }
 935 #endif