src/debug.c

   1 /* debug.c - helpful output in desperate situations
   2    Copyright (C) 2000 Werner Koch (dd9jn)
   3    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2009 g10 Code GmbH
   4
   5    This file is part of GPGME.
   6
   7    GPGME is free software; you can redistribute it and/or modify it
   8    under the terms of the GNU Lesser General Public License as
   9    published by the Free Software Foundation; either version 2.1 of
  10    the License, or (at your option) any later version.
  11
  12    GPGME is distributed in the hope that it will be useful, but
  13    WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    Lesser General Public License for more details.
  16
  17    You should have received a copy of the GNU Lesser General Public
  18    License along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #if HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <stdarg.h>
  29 #ifdef HAVE_UNISTD_H
  30 # include <unistd.h>
  31 #endif
  32 #include <ctype.h>
  33 #include <errno.h>
  34 #include <time.h>
  35 #ifndef HAVE_DOSISH_SYSTEM
  36 #  include <sys/types.h>
  37 #  include <sys/stat.h>
  38 #  include <fcntl.h>
  39 #endif
  40 #include <assert.h>
  41
  42 #include "util.h"
  43 #include "ath.h"
  44 #include "sema.h"
  45 #include "debug.h"
  46
  47 \f
  48 /* Lock to serialize initialization of the debug output subsystem and
  49    output of actual debug messages.  */
  50 DEFINE_STATIC_LOCK (debug_lock);
  51
  52 /* The amount of detail requested by the user, per environment
  53    variable GPGME_DEBUG.  */
  54 static int debug_level;
  55
  56 /* The output stream for the debug messages.  */
  57 static FILE *errfp;
  58
  59 \f
  60 #ifdef HAVE_TLS
  61 #define FRAME_NR
  62 static __thread int frame_nr = 0;
  63 #endif
  64
  65 void
  66 _gpgme_debug_frame_begin (void)
  67 {
  68 #ifdef FRAME_NR
  69   frame_nr++;
  70 #endif
  71 }
  72
  73 void _gpgme_debug_frame_end (void)
  74 {
  75 #ifdef FRAME_NR
  76   frame_nr--;
  77 #endif
  78 }
  79
  80
  81 \f
  82 /* Remove leading and trailing white spaces.  */
  83 static char *
  84 trim_spaces (char *str)
  85 {
  86   char *string, *p, *mark;
  87
  88   string = str;
  89   /* Find first non space character.  */
  90   for (p = string; *p && isspace (*(unsigned char *) p); p++)
  91     ;
  92   /* Move characters.  */
  93   for (mark = NULL; (*string = *p); string++, p++)
  94     if (isspace (*(unsigned char *) p))
  95       {
  96         if (!mark)
  97           mark = string;
  98       }
  99     else
 100       mark = NULL;
 101   if (mark)
 102     *mark = '\0';       /* Remove trailing spaces.  */
 103
 104   return str;
 105 }
 106
 107
 108 static void
 109 debug_init (void)
 110 {
 111   static int initialized;
 112
 113   LOCK (debug_lock);
 114   if (!initialized)
 115     {
 116       gpgme_error_t err;
 117       char *e;
 118       const char *s1, *s2;;
 119
 120 #ifdef HAVE_W32CE_SYSTEM
 121       e = _gpgme_w32ce_get_debug_envvar ();
 122 #else /*!HAVE_W32CE_SYSTEM*/
 123       err = _gpgme_getenv ("GPGME_DEBUG", &e);
 124       if (err)
 125         {
 126           UNLOCK (debug_lock);
 127           return;
 128         }
 129 #endif /*!HAVE_W32CE_SYSTEM*/
 130
 131       initialized = 1;
 132       errfp = stderr;
 133       if (e)
 134         {
 135           debug_level = atoi (e);
 136           s1 = strchr (e, PATHSEP_C);
 137           if (s1)
 138             {
 139 #ifndef HAVE_DOSISH_SYSTEM
 140               if (getuid () == geteuid ()
 141 #if defined(HAVE_GETGID) && defined(HAVE_GETEGID)
 142                   && getgid () == getegid ()
 143 #endif
 144                   )
 145                 {
 146 #endif
 147                   char *p;
 148                   FILE *fp;
 149
 150                   s1++;
 151                   if (!(s2 = strchr (s1, PATHSEP_C)))
 152                     s2 = s1 + strlen (s1);
 153                   p = malloc (s2 - s1 + 1);
 154                   if (p)
 155                     {
 156                       memcpy (p, s1, s2 - s1);
 157                       p[s2-s1] = 0;
 158                       trim_spaces (p);
 159                       fp = fopen (p,"a");
 160                       if (fp)
 161                         {
 162                           setvbuf (fp, NULL, _IOLBF, 0);
 163                           errfp = fp;
 164                         }
 165                       free (p);
 166                     }
 167 #ifndef HAVE_DOSISH_SYSTEM
 168                 }
 169 #endif
 170             }
 171           free (e);
 172         }
 173     }
 174   UNLOCK (debug_lock);
 175
 176   if (debug_level > 0)
 177     _gpgme_debug (DEBUG_INIT, "gpgme_debug: level=%d\n", debug_level);
 178 }
 179
 180
 181
 182 /* This should be called as soon as the locks are intialized.  It is
 183    required so that the assuan logging gets conncted to the gpgme log
 184    stream as early as possible.  */
 185 void
 186 _gpgme_debug_subsystem_init (void)
 187 {
 188   debug_init ();
 189 }
 190
 191
 192
 193 \f
 194 /* Log the formatted string FORMAT at debug level LEVEL or higher.  */
 195 void
 196 _gpgme_debug (int level, const char *format, ...)
 197 {
 198   va_list arg_ptr;
 199   int saved_errno;
 200
 201   saved_errno = errno;
 202   if (debug_level < level)
 203     return;
 204
 205   va_start (arg_ptr, format);
 206   LOCK (debug_lock);
 207   {
 208     struct tm *tp;
 209     time_t atime = time (NULL);
 210
 211     tp = localtime (&atime);
 212     fprintf (errfp, "GPGME %04d-%02d-%02d %02d:%02d:%02d <0x%04llx>  ",
 213              1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday,
 214              tp->tm_hour, tp->tm_min, tp->tm_sec,
 215              (unsigned long long) ath_self ());
 216   }
 217 #ifdef FRAME_NR
 218   {
 219     char spaces[] = "                                        ";
 220     int nr_spaces = sizeof (spaces) - 1;
 221     int nr_columns;
 222
 223     nr_columns = 2 * (frame_nr - 1);
 224     if (nr_columns > nr_spaces)
 225       nr_columns = nr_spaces;
 226     if (nr_columns < 0)
 227       nr_columns = 0;
 228     spaces[nr_columns] = '\0';
 229     fprintf (errfp, "%s", spaces);
 230   }
 231 #endif
 232
 233   vfprintf (errfp, format, arg_ptr);
 234   va_end (arg_ptr);
 235   if(format && *format && format[strlen (format) - 1] != '\n')
 236     putc ('\n', errfp);
 237   UNLOCK (debug_lock);
 238   fflush (errfp);
 239
 240   gpg_err_set_errno (saved_errno);
 241 }
 242
 243
 244 /* Start a new debug line in *LINE, logged at level LEVEL or higher,
 245    and starting with the formatted string FORMAT.  */
 246 void
 247 _gpgme_debug_begin (void **line, int level, const char *format, ...)
 248 {
 249   va_list arg_ptr;
 250   int res;
 251
 252   if (debug_level < level)
 253     {
 254       /* Disable logging of this line.  */
 255       *line = NULL;
 256       return;
 257     }
 258
 259   va_start (arg_ptr, format);
 260   res = vasprintf ((char **) line, format, arg_ptr);
 261   va_end (arg_ptr);
 262   if (res < 0)
 263     *line = NULL;
 264 }
 265
 266
 267 /* Add the formatted string FORMAT to the debug line *LINE.  */
 268 void
 269 _gpgme_debug_add (void **line, const char *format, ...)
 270 {
 271   va_list arg_ptr;
 272   char *toadd;
 273   char *result;
 274   int res;
 275
 276   if (!*line)
 277     return;
 278
 279   va_start (arg_ptr, format);
 280   res = vasprintf (&toadd, format, arg_ptr);
 281   va_end (arg_ptr);
 282   if (res < 0)
 283     {
 284       free (*line);
 285       *line = NULL;
 286     }
 287   res = asprintf (&result, "%s%s", *(char **) line, toadd);
 288   free (toadd);
 289   free (*line);
 290   if (res < 0)
 291     *line = NULL;
 292   else
 293     *line = result;
 294 }
 295
 296
 297 /* Finish construction of *LINE and send it to the debug output
 298    stream.  */
 299 void
 300 _gpgme_debug_end (void **line)
 301 {
 302   if (!*line)
 303     return;
 304
 305   /* The smallest possible level is 1, so force logging here by
 306      using that.  */
 307   _gpgme_debug (1, "%s", *line);
 308   free (*line);
 309   *line = NULL;
 310 }
 311
 312
 313 #define TOHEX(val) (((val) < 10) ? ((val) + '0') : ((val) - 10 + 'a'))
 314
 315 void
 316 _gpgme_debug_buffer (int lvl, const char *const fmt,
 317                      const char *const func, const char *const buffer,
 318                      size_t len)
 319 {
 320   int idx = 0;
 321   int j;
 322
 323   if (!_gpgme_debug_trace ())
 324     return;
 325
 326   while (idx < len)
 327     {
 328       char str[51];
 329       char *strp = str;
 330       char *strp2 = &str[34];
 331
 332       for (j = 0; j < 16; j++)
 333         {
 334           unsigned char val;
 335           if (idx < len)
 336             {
 337               val = buffer[idx++];
 338               *(strp++) = TOHEX (val >> 4);
 339               *(strp++) = TOHEX (val % 16);
 340               *(strp2++) = isprint (val) ? val : '.';
 341             }
 342           else
 343             {
 344               *(strp++) = ' ';
 345               *(strp++) = ' ';
 346             }
 347           if (j == 7)
 348             *(strp++) = ' ';
 349         }
 350       *(strp++) = ' ';
 351       *(strp2) = '\0';
 352
 353       _gpgme_debug (lvl, fmt, func, str);
 354     }
 355 }