* gnupg.7: New mini man page.
[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 FILE *logfp;
35
36 /****************
37  * Set the logfile to use (not yet implemneted) or, if logfile is NULL,
38  * the Fd where logoutputs should go.
39  */
40 void
41 log_set_logfile( const char *name, int fd )
42 {
43     if( name )
44         BUG();
45
46     if( logfp && logfp != stderr && logfp != stdout )
47         fclose( logfp );
48     if( fd == 1 )
49         logfp = stdout;
50     else if( fd == 2 )
51         logfp = stderr;
52     else
53         logfp = fdopen( fd, "a" );
54     if( !logfp ) {
55         logfp = stderr;
56         log_fatal("can't open fd %d for logging: %s\n", fd, strerror(errno));
57     }
58 }
59
60 FILE *
61 log_stream()
62 {
63     if( !logfp )
64         logfp = stderr;
65     return logfp;
66 }
67
68
69 void
70 log_set_name( const char *name )
71 {
72     m_free(pgm_name);
73     if( name )
74         pgm_name = m_strdup(name);
75     else
76         pgm_name = NULL;
77 }
78
79 const char *
80 log_get_name(void)
81 {
82     return pgm_name? pgm_name : "";
83 }
84
85
86 void
87 log_set_pid( int pid )
88 {
89     if( pid )
90         sprintf(pidstring,"[%u]", (unsigned)pid );
91     else
92         *pidstring = 0;
93 }
94
95 int
96 log_get_errorcount( int clear)
97 {
98     int n = errorcount;
99     if( clear )
100         errorcount = 0;
101     return n;
102 }
103
104 void
105 log_inc_errorcount()
106 {
107     errorcount++;
108 }
109
110
111 void
112 g10_log_print_prefix(const char *text)
113 {
114     if( !logfp )
115         logfp = stderr;
116     if( pgm_name )
117         fprintf(logfp, "%s%s: %s", pgm_name, pidstring, text );
118     else
119         fprintf(logfp, "?%s: %s", pidstring, text );
120 #ifdef __riscos__
121     fflush( logfp );
122 #endif /* __riscos__ */
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 #ifdef __riscos__
135     fflush( logfp );
136 #endif /* __riscos__ */
137 }
138
139 void
140 g10_log_info( const char *fmt, ... )
141 {
142     va_list arg_ptr ;
143
144     g10_log_print_prefix("");
145     va_start( arg_ptr, fmt ) ;
146     vfprintf(logfp,fmt,arg_ptr) ;
147     va_end(arg_ptr);
148 #ifdef __riscos__
149     fflush( logfp );
150 #endif /* __riscos__ */
151 }
152
153 void
154 g10_log_info_f( const char *fname, const char *fmt, ... )
155 {
156     va_list arg_ptr ;
157
158     print_prefix_f("", fname);
159     va_start( arg_ptr, fmt ) ;
160     vfprintf(logfp,fmt,arg_ptr) ;
161     va_end(arg_ptr);
162 #ifdef __riscos__
163     fflush( logfp );
164 #endif /* __riscos__ */
165 }
166
167 void
168 g10_log_error( const char *fmt, ... )
169 {
170     va_list arg_ptr ;
171
172     g10_log_print_prefix("");
173     va_start( arg_ptr, fmt ) ;
174     vfprintf(logfp,fmt,arg_ptr) ;
175     va_end(arg_ptr);
176     errorcount++;
177 #ifdef __riscos__
178     fflush( logfp );
179 #endif /* __riscos__ */
180 }
181
182 void
183 g10_log_error_f( const char *fname, const char *fmt, ... )
184 {
185     va_list arg_ptr ;
186
187     print_prefix_f("", fname);
188     va_start( arg_ptr, fmt ) ;
189     vfprintf(logfp,fmt,arg_ptr) ;
190     va_end(arg_ptr);
191     errorcount++;
192 #ifdef __riscos__
193     fflush( logfp );
194 #endif /* __riscos__ */
195 }
196
197 void
198 g10_log_fatal( const char *fmt, ... )
199 {
200     va_list arg_ptr ;
201
202     g10_log_print_prefix("fatal: ");
203     va_start( arg_ptr, fmt ) ;
204     vfprintf(logfp,fmt,arg_ptr) ;
205     va_end(arg_ptr);
206     secmem_dump_stats();
207 #ifdef __riscos__
208     fflush( logfp );
209 #endif /* __riscos__ */
210     exit(2);
211 }
212
213 void
214 g10_log_fatal_f( const char *fname, const char *fmt, ... )
215 {
216     va_list arg_ptr ;
217
218     print_prefix_f("fatal: ", fname);
219     va_start( arg_ptr, fmt ) ;
220     vfprintf(logfp,fmt,arg_ptr) ;
221     va_end(arg_ptr);
222     secmem_dump_stats();
223 #ifdef __riscos__
224     fflush( logfp );
225 #endif /* __riscos__ */
226     exit(2);
227 }
228
229 void
230 g10_log_bug( const char *fmt, ... )
231 {
232     va_list arg_ptr ;
233
234     putc('\n', stderr );
235     g10_log_print_prefix("Ohhhh jeeee: ");
236     va_start( arg_ptr, fmt ) ;
237     vfprintf(stderr,fmt,arg_ptr) ;
238     va_end(arg_ptr);
239     fflush(stderr);
240     secmem_dump_stats();
241     abort();
242 }
243
244 #if defined (__riscos__) \
245     || ( __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 ))
246 void
247 g10_log_bug0( const char *file, int line, const char *func )
248 {
249     log_bug(_("... this is a bug (%s:%d:%s)\n"), file, line, func );
250 }
251 #else
252 void
253 g10_log_bug0( const char *file, int line )
254 {
255     log_bug(_("you found a bug ... (%s:%d)\n"), file, line);
256 }
257 #endif
258
259 void
260 g10_log_debug( const char *fmt, ... )
261 {
262     va_list arg_ptr ;
263
264     g10_log_print_prefix("DBG: ");
265     va_start( arg_ptr, fmt ) ;
266     vfprintf(logfp,fmt,arg_ptr) ;
267     va_end(arg_ptr);
268 #ifdef __riscos__
269     fflush( logfp );
270 #endif /* __riscos__ */
271 }
272
273 void
274 g10_log_debug_f( const char *fname, const char *fmt, ... )
275 {
276     va_list arg_ptr ;
277
278     print_prefix_f("DBG: ", fname);
279     va_start( arg_ptr, fmt ) ;
280     vfprintf(logfp,fmt,arg_ptr) ;
281     va_end(arg_ptr);
282 #ifdef __riscos__
283     fflush( logfp );
284 #endif /* __riscos__ */
285 }
286
287
288
289 void
290 g10_log_hexdump( const char *text, const char *buf, size_t len )
291 {
292     int i;
293
294     g10_log_print_prefix(text);
295     for(i=0; i < len; i++ )
296         fprintf(logfp, " %02X", ((const byte*)buf)[i] );
297     fputc('\n', logfp);
298 #ifdef __riscos__
299     fflush( logfp );
300 #endif /* __riscos__ */
301 }
302
303
304