* mkdtemp.c: New (moved from g10/), setenv.c: New, unsetenv.c: New.
[gnupg.git] / util / logger.c
1 /* logger.c  -  log functions
2  *      Copyright (C) 1998, 1999 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
28 #include "util.h"
29 #include "i18n.h"
30
31 static char pidstring[15];
32 static char *pgm_name;
33 static int errorcount;
34 static int strict;
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( name )
45         BUG();
46
47     if( logfp && logfp != stderr && logfp != stdout )
48         fclose( logfp );
49     if( fd == 1 )
50         logfp = stdout;
51     else if( fd == 2 )
52         logfp = stderr;
53     else
54         logfp = fdopen( fd, "a" );
55     if( !logfp ) {
56         logfp = stderr;
57         log_fatal("can't open fd %d for logging: %s\n", fd, strerror(errno));
58     }
59 }
60
61 FILE *
62 log_stream()
63 {
64     if( !logfp )
65         logfp = stderr;
66     return logfp;
67 }
68
69
70 void
71 log_set_name( const char *name )
72 {
73     m_free(pgm_name);
74     if( name )
75         pgm_name = m_strdup(name);
76     else
77         pgm_name = NULL;
78 }
79
80 const char *
81 log_get_name(void)
82 {
83     return pgm_name? pgm_name : "";
84 }
85
86
87 void
88 log_set_pid( int pid )
89 {
90     if( pid )
91         sprintf(pidstring,"[%u]", (unsigned)pid );
92     else
93         *pidstring = 0;
94 }
95
96 int
97 log_get_errorcount( int clear)
98 {
99     int n = errorcount;
100     if( clear )
101         errorcount = 0;
102     return n;
103 }
104
105 void
106 log_inc_errorcount()
107 {
108     errorcount++;
109 }
110
111 int
112 log_set_strict(int val)
113 {
114   int old=strict;
115   strict=val;
116   return old;
117 }
118
119 void
120 g10_log_print_prefix(const char *text)
121 {
122     if( !logfp )
123         logfp = stderr;
124     if( pgm_name )
125         fprintf(logfp, "%s%s: %s", pgm_name, pidstring, text );
126     else
127         fprintf(logfp, "?%s: %s", pidstring, text );
128 #ifdef __riscos__
129     fflush( logfp );
130 #endif /* __riscos__ */
131 }
132
133 static void
134 print_prefix_f(const char *text, const char *fname)
135 {
136     if( !logfp )
137         logfp = stderr;
138     if( pgm_name )
139         fprintf(logfp, "%s%s:%s: %s", pgm_name, pidstring, fname, text );
140     else
141         fprintf(logfp, "?%s:%s: %s", pidstring, fname, text );
142 #ifdef __riscos__
143     fflush( logfp );
144 #endif /* __riscos__ */
145 }
146
147 void
148 g10_log_info( const char *fmt, ... )
149 {
150     va_list arg_ptr ;
151
152     g10_log_print_prefix("");
153     va_start( arg_ptr, fmt ) ;
154     vfprintf(logfp,fmt,arg_ptr) ;
155     va_end(arg_ptr);
156 #ifdef __riscos__
157     fflush( logfp );
158 #endif /* __riscos__ */
159 }
160
161 void
162 g10_log_info_f( const char *fname, const char *fmt, ... )
163 {
164     va_list arg_ptr ;
165
166     print_prefix_f("", fname);
167     va_start( arg_ptr, fmt ) ;
168     vfprintf(logfp,fmt,arg_ptr) ;
169     va_end(arg_ptr);
170 #ifdef __riscos__
171     fflush( logfp );
172 #endif /* __riscos__ */
173 }
174
175 void
176 g10_log_warning( const char *fmt, ... )
177 {
178     va_list arg_ptr ;
179
180     if(strict)
181       {
182         errorcount++;
183         g10_log_print_prefix(_("ERROR: "));
184       }
185     else
186       g10_log_print_prefix(_("WARNING: "));
187
188     va_start( arg_ptr, fmt ) ;
189     vfprintf(logfp,fmt,arg_ptr) ;
190     va_end(arg_ptr);
191 #ifdef __riscos__
192     fflush( logfp );
193 #endif /* __riscos__ */
194 }
195
196
197 void
198 g10_log_error( const char *fmt, ... )
199 {
200     va_list arg_ptr ;
201
202     g10_log_print_prefix("");
203     va_start( arg_ptr, fmt ) ;
204     vfprintf(logfp,fmt,arg_ptr) ;
205     va_end(arg_ptr);
206     errorcount++;
207 #ifdef __riscos__
208     fflush( logfp );
209 #endif /* __riscos__ */
210 }
211
212 void
213 g10_log_error_f( const char *fname, const char *fmt, ... )
214 {
215     va_list arg_ptr ;
216
217     print_prefix_f("", fname);
218     va_start( arg_ptr, fmt ) ;
219     vfprintf(logfp,fmt,arg_ptr) ;
220     va_end(arg_ptr);
221     errorcount++;
222 #ifdef __riscos__
223     fflush( logfp );
224 #endif /* __riscos__ */
225 }
226
227 void
228 g10_log_fatal( const char *fmt, ... )
229 {
230     va_list arg_ptr ;
231
232     g10_log_print_prefix("fatal: ");
233     va_start( arg_ptr, fmt ) ;
234     vfprintf(logfp,fmt,arg_ptr) ;
235     va_end(arg_ptr);
236     secmem_dump_stats();
237 #ifdef __riscos__
238     fflush( logfp );
239 #endif /* __riscos__ */
240     exit(2);
241 }
242
243 void
244 g10_log_fatal_f( const char *fname, const char *fmt, ... )
245 {
246     va_list arg_ptr ;
247
248     print_prefix_f("fatal: ", fname);
249     va_start( arg_ptr, fmt ) ;
250     vfprintf(logfp,fmt,arg_ptr) ;
251     va_end(arg_ptr);
252     secmem_dump_stats();
253 #ifdef __riscos__
254     fflush( logfp );
255 #endif /* __riscos__ */
256     exit(2);
257 }
258
259 void
260 g10_log_bug( const char *fmt, ... )
261 {
262     va_list arg_ptr ;
263
264     putc('\n', stderr );
265     g10_log_print_prefix("Ohhhh jeeee: ");
266     va_start( arg_ptr, fmt ) ;
267     vfprintf(stderr,fmt,arg_ptr) ;
268     va_end(arg_ptr);
269     fflush(stderr);
270     secmem_dump_stats();
271     abort();
272 }
273
274 #if defined (__riscos__) \
275     || ( __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 ))
276 void
277 g10_log_bug0( const char *file, int line, const char *func )
278 {
279     log_bug(_("... this is a bug (%s:%d:%s)\n"), file, line, func );
280 }
281 #else
282 void
283 g10_log_bug0( const char *file, int line )
284 {
285     log_bug(_("you found a bug ... (%s:%d)\n"), file, line);
286 }
287 #endif
288
289 void
290 g10_log_debug( const char *fmt, ... )
291 {
292     va_list arg_ptr ;
293
294     g10_log_print_prefix("DBG: ");
295     va_start( arg_ptr, fmt ) ;
296     vfprintf(logfp,fmt,arg_ptr) ;
297     va_end(arg_ptr);
298 #ifdef __riscos__
299     fflush( logfp );
300 #endif /* __riscos__ */
301 }
302
303 void
304 g10_log_debug_f( const char *fname, const char *fmt, ... )
305 {
306     va_list arg_ptr ;
307
308     print_prefix_f("DBG: ", fname);
309     va_start( arg_ptr, fmt ) ;
310     vfprintf(logfp,fmt,arg_ptr) ;
311     va_end(arg_ptr);
312 #ifdef __riscos__
313     fflush( logfp );
314 #endif /* __riscos__ */
315 }
316
317
318
319 void
320 g10_log_hexdump( const char *text, const char *buf, size_t len )
321 {
322     int i;
323
324     g10_log_print_prefix(text);
325     for(i=0; i < len; i++ )
326         fprintf(logfp, " %02X", ((const byte*)buf)[i] );
327     fputc('\n', logfp);
328 #ifdef __riscos__
329     fflush( logfp );
330 #endif /* __riscos__ */
331 }
332
333
334