bf1ca18c15572fc2fec35072bee3f1fe4a8dcf90
[gpgme.git] / 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 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 #include <unistd.h>
30 #include <ctype.h>
31 #include <errno.h>
32 #ifndef HAVE_DOSISH_SYSTEM
33 #  include <sys/types.h>
34 #  include <sys/stat.h>
35 #  include <fcntl.h>
36 #endif
37 #include <assert.h>
38
39 #ifdef HAVE_ASSUAN_H
40 #include "assuan.h"
41 #endif
42
43 #include "util.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 /* Remove leading and trailing white spaces.  */
61 static char *
62 trim_spaces (char *str)
63 {
64   char *string, *p, *mark;
65
66   string = str;
67   /* Find first non space character.  */
68   for (p = string; *p && isspace (*(unsigned char *) p); p++)
69     ;
70   /* Move characters.  */
71   for (mark = NULL; (*string = *p); string++, p++)
72     if (isspace (*(unsigned char *) p))
73       {
74         if (!mark)
75           mark = string;
76       }
77     else
78       mark = NULL;
79   if (mark)
80     *mark = '\0';       /* Remove trailing spaces.  */
81
82   return str;
83 }
84
85
86 static void
87 debug_init (void)
88 {
89   static int initialized;
90
91   LOCK (debug_lock);
92   if (!initialized)
93     {
94       gpgme_error_t err;
95       char *e;
96       const char *s1, *s2;;
97
98       err = _gpgme_getenv ("GPGME_DEBUG", &e);
99       if (err)
100         {
101           UNLOCK (debug_lock);
102           return;
103         }
104
105       initialized = 1;
106       errfp = stderr;
107       if (e)
108         {
109           debug_level = atoi (e);
110           s1 = strchr (e, PATHSEP_C);
111           if (s1)
112             {
113 #ifndef HAVE_DOSISH_SYSTEM
114               if (getuid () == geteuid ())
115                 {
116 #endif
117                   char *p;
118                   FILE *fp;
119
120                   s1++;
121                   if (!(s2 = strchr (s1, PATHSEP_C)))
122                     s2 = s1 + strlen (s1);
123                   p = malloc (s2 - s1 + 1);
124                   if (p)
125                     {
126                       memcpy (p, s1, s2 - s1);
127                       p[s2-s1] = 0;
128                       trim_spaces (p);
129                       fp = fopen (p,"a");
130                       if (fp)
131                         {
132                           setvbuf (fp, NULL, _IOLBF, 0);
133                           errfp = fp;
134                         }
135                       free (p);
136                     }
137 #ifndef HAVE_DOSISH_SYSTEM
138                 }
139 #endif
140             }
141           free (e);
142         }
143
144       if (debug_level > 0)
145         fprintf (errfp, "gpgme_debug: level=%d\n", debug_level);
146 #ifdef HAVE_ASSUAN_H
147       assuan_set_assuan_log_prefix ("gpgme-assuan");
148       assuan_set_assuan_log_stream (errfp);
149       assuan_set_assuan_log_level (debug_level >= 0? debug_level:0);
150 #endif /* HAVE_ASSUAN_H*/
151     }
152   UNLOCK (debug_lock);
153 }
154
155
156
157 /* This should be called as soon as the locks are intialized.  It is
158    required so that the assuan logging gets conncted to the gpgme log
159    stream as early as possible.  */
160 void
161 _gpgme_debug_subsystem_init (void)
162 {
163   debug_init ();
164 }
165
166
167
168 \f
169 /* Log the formatted string FORMAT at debug level LEVEL or higher.  */
170 void
171 _gpgme_debug (int level, const char *format, ...)
172 {
173   va_list arg_ptr;
174   int saved_errno;
175
176   saved_errno = errno;
177
178   debug_init ();
179   if (debug_level < level)
180     return;
181     
182   va_start (arg_ptr, format);
183   LOCK (debug_lock);
184   vfprintf (errfp, format, arg_ptr);
185   va_end (arg_ptr);
186   if(format && *format && format[strlen (format) - 1] != '\n')
187     putc ('\n', errfp);
188   UNLOCK (debug_lock);
189   fflush (errfp);
190
191   errno = saved_errno;
192 }
193
194
195 /* Start a new debug line in *LINE, logged at level LEVEL or higher,
196    and starting with the formatted string FORMAT.  */
197 void
198 _gpgme_debug_begin (void **line, int level, const char *format, ...)
199 {
200   va_list arg_ptr;
201
202   debug_init ();
203   if (debug_level < level)
204     {
205       /* Disable logging of this line.  */
206       *line = NULL;
207       return;
208     }
209
210   va_start (arg_ptr, format);
211   vasprintf ((char **) line, format, arg_ptr);
212   va_end (arg_ptr);
213 }
214
215
216 /* Add the formatted string FORMAT to the debug line *LINE.  */
217 void
218 _gpgme_debug_add (void **line, const char *format, ...)
219 {
220   va_list arg_ptr;
221   char *toadd;
222   char *result;
223
224   if (!*line)
225     return;
226
227   va_start (arg_ptr, format);
228   vasprintf (&toadd, format, arg_ptr);
229   va_end (arg_ptr);
230   asprintf (&result, "%s%s", *(char **) line, toadd);
231   free (*line);
232   free (toadd);
233   *line = result;
234 }
235
236
237 /* Finish construction of *LINE and send it to the debug output
238    stream.  */
239 void
240 _gpgme_debug_end (void **line)
241 {
242   if (!*line)
243     return;
244
245   /* The smallest possible level is 1, so force logging here by
246      using that.  */
247   _gpgme_debug (1, "%s", *line);
248   free (*line);
249   *line = NULL;
250 }
251
252
253 #define TOHEX(val) (((val) < 10) ? ((val) + '0') : ((val) - 10 + 'a'))
254
255 void
256 _gpgme_debug_buffer (int lvl, const char *const fmt,
257                      const char *const func, const char *const tagname,
258                      void *tag, const char *const buffer, size_t len)
259 {
260   int idx = 0;
261   int j;
262
263   if (!_gpgme_debug_trace ())
264     return;
265
266   while (idx < len)
267     {
268       char str[51];
269       char *strp = str;
270       char *strp2 = &str[34];
271       
272       for (j = 0; j < 16; j++)
273         {
274           unsigned char val;
275           if (idx < len)
276             {
277               val = buffer[idx++];
278               *(strp++) = TOHEX (val >> 4);
279               *(strp++) = TOHEX (val % 16);
280               *(strp2++) = isprint (val) ? val : '.';
281             }
282           else
283             {
284               *(strp++) = ' ';
285               *(strp++) = ' ';
286             }
287           if (j == 7)
288             *(strp++) = ' ';
289         }
290       *(strp++) = ' ';
291       *(strp2) = '\0';
292
293       _gpgme_debug (lvl, fmt, func, tagname, tag, str);
294     }
295 }