* argparse.c (default_strusage): Update copyright year to 2006.
[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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19  * USA.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <stdarg.h>
26 #include <string.h>
27 #include <errno.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 int strict;
36 static FILE *logfp;
37
38 /****************
39  * Set the logfile to use (not yet implemneted) or, if logfile is NULL,
40  * the Fd where logoutputs should go.
41  */
42 void
43 log_set_logfile( const char *name, int fd )
44 {
45     if( name )
46         BUG();
47
48     if( logfp && logfp != stderr && logfp != stdout )
49         fclose( logfp );
50     if( fd == 1 )
51         logfp = stdout;
52     else if( fd == 2 )
53         logfp = stderr;
54     else
55         logfp = fdopen( fd, "a" );
56     if( !logfp ) {
57         logfp = stderr;
58         log_fatal("can't open fd %d for logging: %s\n", fd, strerror(errno));
59     }
60 }
61
62 FILE *
63 log_stream()
64 {
65     if( !logfp )
66         logfp = stderr;
67     return logfp;
68 }
69
70
71 void
72 log_set_name( const char *name )
73 {
74     xfree(pgm_name);
75     if( name )
76         pgm_name = xstrdup(name);
77     else
78         pgm_name = NULL;
79 }
80
81 const char *
82 log_get_name(void)
83 {
84     return pgm_name? pgm_name : "";
85 }
86
87
88 void
89 log_set_pid( int pid )
90 {
91     if( pid )
92         sprintf(pidstring,"[%u]", (unsigned)pid );
93     else
94         *pidstring = 0;
95 }
96
97 int
98 log_get_errorcount( int clear)
99 {
100     int n = errorcount;
101     if( clear )
102         errorcount = 0;
103     return n;
104 }
105
106 void
107 log_inc_errorcount()
108 {
109     errorcount++;
110 }
111
112 int
113 log_set_strict(int val)
114 {
115   int old=strict;
116   strict=val;
117   return old;
118 }
119
120 void
121 g10_log_print_prefix(const char *text)
122 {
123     if( !logfp )
124         logfp = stderr;
125     if( pgm_name )
126         fprintf(logfp, "%s%s: %s", pgm_name, pidstring, text );
127     else
128         fprintf(logfp, "?%s: %s", pidstring, text );
129 #ifdef __riscos__
130     fflush( logfp );
131 #endif /* __riscos__ */
132 }
133
134
135 void
136 g10_log_info( const char *fmt, ... )
137 {
138     va_list arg_ptr ;
139
140     g10_log_print_prefix("");
141     va_start( arg_ptr, fmt ) ;
142     vfprintf(logfp,fmt,arg_ptr) ;
143     va_end(arg_ptr);
144 #ifdef __riscos__
145     fflush( logfp );
146 #endif /* __riscos__ */
147 }
148
149
150 void
151 g10_log_warning( const char *fmt, ... )
152 {
153     va_list arg_ptr ;
154
155     if(strict)
156       {
157         errorcount++;
158         g10_log_print_prefix(_("ERROR: "));
159       }
160     else
161       g10_log_print_prefix(_("WARNING: "));
162
163     va_start( arg_ptr, fmt ) ;
164     vfprintf(logfp,fmt,arg_ptr) ;
165     va_end(arg_ptr);
166 #ifdef __riscos__
167     fflush( logfp );
168 #endif /* __riscos__ */
169 }
170
171
172 void
173 g10_log_error( const char *fmt, ... )
174 {
175     va_list arg_ptr ;
176
177     g10_log_print_prefix("");
178     va_start( arg_ptr, fmt ) ;
179     vfprintf(logfp,fmt,arg_ptr) ;
180     va_end(arg_ptr);
181     errorcount++;
182 #ifdef __riscos__
183     fflush( logfp );
184 #endif /* __riscos__ */
185 }
186
187
188 void
189 g10_log_fatal( const char *fmt, ... )
190 {
191     va_list arg_ptr ;
192
193     g10_log_print_prefix("fatal: ");
194     va_start( arg_ptr, fmt ) ;
195     vfprintf(logfp,fmt,arg_ptr) ;
196     va_end(arg_ptr);
197     secmem_dump_stats();
198 #ifdef __riscos__
199     fflush( logfp );
200 #endif /* __riscos__ */
201     exit(2);
202 }
203
204 void
205 g10_log_bug( const char *fmt, ... )
206 {
207     va_list arg_ptr ;
208
209     putc('\n', stderr );
210     g10_log_print_prefix("Ohhhh jeeee: ");
211     va_start( arg_ptr, fmt ) ;
212     vfprintf(stderr,fmt,arg_ptr) ;
213     va_end(arg_ptr);
214     fflush(stderr);
215     secmem_dump_stats();
216     abort();
217 }
218
219 #if defined (__riscos__) \
220     || ( __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 ))
221 void
222 g10_log_bug0( const char *file, int line, const char *func )
223 {
224     log_bug(_("... this is a bug (%s:%d:%s)\n"), file, line, func );
225 }
226 #else
227 void
228 g10_log_bug0( const char *file, int line )
229 {
230     log_bug(_("you found a bug ... (%s:%d)\n"), file, line);
231 }
232 #endif
233
234 void
235 g10_log_debug( const char *fmt, ... )
236 {
237     va_list arg_ptr ;
238
239     g10_log_print_prefix("DBG: ");
240     va_start( arg_ptr, fmt ) ;
241     vfprintf(logfp,fmt,arg_ptr) ;
242     va_end(arg_ptr);
243 #ifdef __riscos__
244     fflush( logfp );
245 #endif /* __riscos__ */
246 }
247
248
249
250 void
251 g10_log_hexdump( const char *text, const char *buf, size_t len )
252 {
253     int i;
254
255     g10_log_print_prefix(text);
256     for(i=0; i < len; i++ )
257         fprintf(logfp, " %02X", ((const byte*)buf)[i] );
258     fputc('\n', logfp);
259 #ifdef __riscos__
260     fflush( logfp );
261 #endif /* __riscos__ */
262 }
263
264
265