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