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