See ChangeLog: Fri Aug 18 14:27:14 CEST 2000 Werner Koch
[gnupg.git] / util / logger.c
1 /* logger.c  -  log functions
2  *      Copyright (C) 1998, 2000 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <stdarg.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <gcrypt.h>
28
29 #include "util.h"
30 #include "i18n.h"
31
32 static char pidstring[15];
33 static char *pgm_name;
34 static int errorcount;
35 static FILE *logfp;
36
37 /****************
38  * Set the logfile to use (not yet implemneted) or, if logfile is NULL,
39  * the Fd where logoutputs should go.
40  */
41 void
42 log_set_logfile( const char *name, int fd )
43 {
44     if( logfp && logfp != stderr && logfp != stdout )
45         fclose( logfp );
46     if( name ) {
47         logfp = fopen ( name, "a" );
48     }
49     else {
50         if( fd == 1 )
51             logfp = stdout;
52         else if( fd == 2 )
53             logfp = stderr;
54         else
55             logfp = fdopen( fd, "a" );
56     }
57     if( !logfp ) {
58         logfp = stderr;
59         log_fatal("can't open fd %d for logging: %s\n", fd, strerror(errno));
60     }
61 }
62
63 FILE *
64 log_stream()
65 {
66     if( !logfp )
67         logfp = stderr;
68     return logfp;
69 }
70
71
72 void
73 log_set_name( const char *name )
74 {
75     gcry_free(pgm_name);
76     if( name )
77         pgm_name = gcry_xstrdup(name);
78     else
79         pgm_name = NULL;
80 }
81
82 const char *
83 log_get_name(void)
84 {
85     return pgm_name? pgm_name : "";
86 }
87
88
89 void
90 log_set_pid( int pid )
91 {
92     if( pid )
93         sprintf(pidstring,"[%u]", (unsigned)pid );
94     else
95         *pidstring = 0;
96 }
97
98 int
99 log_get_errorcount( int clear)
100 {
101     int n = errorcount;
102     if( clear )
103         errorcount = 0;
104     return n;
105 }
106
107 void
108 log_inc_errorcount()
109 {
110     errorcount++;
111 }
112
113
114 void
115 gpg_log_print_prefix(const char *text)
116 {
117     if( !logfp )
118         logfp = stderr;
119     if( pgm_name )
120         fprintf(logfp, "%s%s: %s", pgm_name, pidstring, text );
121     else
122         fprintf(logfp, "?%s: %s", pidstring, text );
123 }
124
125 static void
126 print_prefix_f(const char *text, const char *fname)
127 {
128     if( !logfp )
129         logfp = stderr;
130     if( pgm_name )
131         fprintf(logfp, "%s%s:%s: %s", pgm_name, pidstring, fname, text );
132     else
133         fprintf(logfp, "?%s:%s: %s", pidstring, fname, text );
134 }
135
136 void
137 gpg_log_info( const char *fmt, ... )
138 {
139     va_list arg_ptr ;
140
141     gpg_log_print_prefix("");
142     va_start( arg_ptr, fmt ) ;
143     vfprintf(logfp,fmt,arg_ptr) ;
144     va_end(arg_ptr);
145 }
146
147 void
148 gpg_log_info_f( const char *fname, const char *fmt, ... )
149 {
150     va_list arg_ptr ;
151
152     print_prefix_f("", fname);
153     va_start( arg_ptr, fmt ) ;
154     vfprintf(logfp,fmt,arg_ptr) ;
155     va_end(arg_ptr);
156 }
157
158 void
159 gpg_log_error( const char *fmt, ... )
160 {
161     va_list arg_ptr ;
162
163     gpg_log_print_prefix("");
164     va_start( arg_ptr, fmt ) ;
165     vfprintf(logfp,fmt,arg_ptr) ;
166     va_end(arg_ptr);
167     errorcount++;
168 }
169
170 void
171 gpg_log_error_f( const char *fname, const char *fmt, ... )
172 {
173     va_list arg_ptr ;
174
175     print_prefix_f("", fname);
176     va_start( arg_ptr, fmt ) ;
177     vfprintf(logfp,fmt,arg_ptr) ;
178     va_end(arg_ptr);
179     errorcount++;
180 }
181
182 void
183 gpg_log_fatal( const char *fmt, ... )
184 {
185     va_list arg_ptr ;
186
187     gpg_log_print_prefix("fatal: ");
188     va_start( arg_ptr, fmt ) ;
189     vfprintf(logfp,fmt,arg_ptr) ;
190     va_end(arg_ptr);
191     secmem_dump_stats();
192     exit(2);
193 }
194
195 void
196 gpg_log_fatal_f( const char *fname, const char *fmt, ... )
197 {
198     va_list arg_ptr ;
199
200     print_prefix_f("fatal: ", fname);
201     va_start( arg_ptr, fmt ) ;
202     vfprintf(logfp,fmt,arg_ptr) ;
203     va_end(arg_ptr);
204     secmem_dump_stats();
205     exit(2);
206 }
207
208 void
209 gpg_log_bug( const char *fmt, ... )
210 {
211     va_list arg_ptr ;
212
213     putc('\n', stderr );
214     gpg_log_print_prefix("Ohhhh jeeee: ");
215     va_start( arg_ptr, fmt ) ;
216     vfprintf(stderr,fmt,arg_ptr) ;
217     va_end(arg_ptr);
218     fflush(stderr);
219     secmem_dump_stats();
220     abort();
221 }
222
223 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 )
224 void
225 gpg_log_bug0( const char *file, int line, const char *func )
226 {
227     log_bug(_("... this is a bug (%s:%d:%s)\n"), file, line, func );
228 }
229 #else
230 void
231 gpg_log_bug0( const char *file, int line )
232 {
233     log_bug(_("you found a bug ... (%s:%d)\n"), file, line);
234 }
235 #endif
236
237 void
238 gpg_log_debug( const char *fmt, ... )
239 {
240     va_list arg_ptr ;
241
242     gpg_log_print_prefix("DBG: ");
243     va_start( arg_ptr, fmt ) ;
244     vfprintf(logfp,fmt,arg_ptr) ;
245     va_end(arg_ptr);
246 }
247
248 void
249 gpg_log_debug_f( const char *fname, const char *fmt, ... )
250 {
251     va_list arg_ptr ;
252
253     print_prefix_f("DBG: ", fname);
254     va_start( arg_ptr, fmt ) ;
255     vfprintf(logfp,fmt,arg_ptr) ;
256     va_end(arg_ptr);
257 }
258
259
260
261 void
262 gpg_log_hexdump( const char *text, const char *buf, size_t len )
263 {
264     int i;
265
266     gpg_log_print_prefix(text);
267     for(i=0; i < len; i++ )
268         fprintf(logfp, " %02X", ((const byte*)buf)[i] );
269     fputc('\n', logfp);
270 }
271
272
273