See ChangeLog: Sat May 22 22:47:26 CEST 1999 Werner Koch
[gnupg.git] / util / logger.c
1 /* logger.c  -  log functions
2  *      Copyright (C) 1998 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
105 static void
106 print_prefix(const char *text)
107 {
108     if( !logfp )
109         logfp = stderr;
110     if( pgm_name )
111         fprintf(logfp, "%s%s: %s", pgm_name, pidstring, text );
112     else
113         fprintf(logfp, "?%s: %s", pidstring, text );
114 }
115
116 static void
117 print_prefix_f(const char *text, const char *fname)
118 {
119     if( !logfp )
120         logfp = stderr;
121     if( pgm_name )
122         fprintf(logfp, "%s%s:%s: %s", pgm_name, pidstring, fname, text );
123     else
124         fprintf(logfp, "?%s:%s: %s", pidstring, fname, text );
125 }
126
127 void
128 g10_log_info( const char *fmt, ... )
129 {
130     va_list arg_ptr ;
131
132     print_prefix("");
133     va_start( arg_ptr, fmt ) ;
134     vfprintf(logfp,fmt,arg_ptr) ;
135     va_end(arg_ptr);
136 }
137
138 void
139 g10_log_info_f( const char *fname, const char *fmt, ... )
140 {
141     va_list arg_ptr ;
142
143     print_prefix_f("", fname);
144     va_start( arg_ptr, fmt ) ;
145     vfprintf(logfp,fmt,arg_ptr) ;
146     va_end(arg_ptr);
147 }
148
149 void
150 g10_log_error( const char *fmt, ... )
151 {
152     va_list arg_ptr ;
153
154     print_prefix("");
155     va_start( arg_ptr, fmt ) ;
156     vfprintf(logfp,fmt,arg_ptr) ;
157     va_end(arg_ptr);
158     errorcount++;
159 }
160
161 void
162 g10_log_error_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     errorcount++;
171 }
172
173 void
174 g10_log_fatal( const char *fmt, ... )
175 {
176     va_list arg_ptr ;
177
178     print_prefix("fatal: ");
179     va_start( arg_ptr, fmt ) ;
180     vfprintf(logfp,fmt,arg_ptr) ;
181     va_end(arg_ptr);
182     secmem_dump_stats();
183     exit(2);
184 }
185
186 void
187 g10_log_fatal_f( const char *fname, const char *fmt, ... )
188 {
189     va_list arg_ptr ;
190
191     print_prefix_f("fatal: ", fname);
192     va_start( arg_ptr, fmt ) ;
193     vfprintf(logfp,fmt,arg_ptr) ;
194     va_end(arg_ptr);
195     secmem_dump_stats();
196     exit(2);
197 }
198
199 void
200 g10_log_bug( const char *fmt, ... )
201 {
202     va_list arg_ptr ;
203
204     putc('\n', stderr );
205     print_prefix("Ohhhh jeeee: ");
206     va_start( arg_ptr, fmt ) ;
207     vfprintf(stderr,fmt,arg_ptr) ;
208     va_end(arg_ptr);
209     fflush(stderr);
210     secmem_dump_stats();
211     abort();
212 }
213
214 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 )
215 void
216 g10_log_bug0( const char *file, int line, const char *func )
217 {
218     log_bug(_("... this is a bug (%s:%d:%s)\n"), file, line, func );
219 }
220 #else
221 void
222 g10_log_bug0( const char *file, int line )
223 {
224     log_bug(_("you found a bug ... (%s:%d)\n"), file, line);
225 }
226 #endif
227
228 void
229 g10_log_debug( const char *fmt, ... )
230 {
231     va_list arg_ptr ;
232
233     print_prefix("DBG: ");
234     va_start( arg_ptr, fmt ) ;
235     vfprintf(logfp,fmt,arg_ptr) ;
236     va_end(arg_ptr);
237 }
238
239 void
240 g10_log_debug_f( const char *fname, const char *fmt, ... )
241 {
242     va_list arg_ptr ;
243
244     print_prefix_f("DBG: ", fname);
245     va_start( arg_ptr, fmt ) ;
246     vfprintf(logfp,fmt,arg_ptr) ;
247     va_end(arg_ptr);
248 }
249
250
251
252 void
253 g10_log_hexdump( const char *text, const char *buf, size_t len )
254 {
255     int i;
256
257     print_prefix(text);
258     for(i=0; i < len; i++ )
259         fprintf(logfp, " %02X", ((const byte*)buf)[i] );
260     fputc('\n', logfp);
261 }
262
263
264 void
265 g10_log_mpidump( const char *text, MPI a )
266 {
267     print_prefix(text);
268     mpi_print(logfp, a, 1 );
269     fputc('\n', logfp);
270 }
271