See ChangeLog: Thu Jan 27 18:00:44 CET 2000 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 #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( 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     gcry_free(pgm_name);
74     if( name )
75         pgm_name = gcry_xstrdup(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
106 void
107 gpg_log_print_prefix(const char *text)
108 {
109     if( !logfp )
110         logfp = stderr;
111     if( pgm_name )
112         fprintf(logfp, "%s%s: %s", pgm_name, pidstring, text );
113     else
114         fprintf(logfp, "?%s: %s", pidstring, text );
115 }
116
117 static void
118 print_prefix_f(const char *text, const char *fname)
119 {
120     if( !logfp )
121         logfp = stderr;
122     if( pgm_name )
123         fprintf(logfp, "%s%s:%s: %s", pgm_name, pidstring, fname, text );
124     else
125         fprintf(logfp, "?%s:%s: %s", pidstring, fname, text );
126 }
127
128 void
129 gpg_log_info( const char *fmt, ... )
130 {
131     va_list arg_ptr ;
132
133     gpg_log_print_prefix("");
134     va_start( arg_ptr, fmt ) ;
135     vfprintf(logfp,fmt,arg_ptr) ;
136     va_end(arg_ptr);
137 }
138
139 void
140 gpg_log_info_f( const char *fname, const char *fmt, ... )
141 {
142     va_list arg_ptr ;
143
144     print_prefix_f("", fname);
145     va_start( arg_ptr, fmt ) ;
146     vfprintf(logfp,fmt,arg_ptr) ;
147     va_end(arg_ptr);
148 }
149
150 void
151 gpg_log_error( const char *fmt, ... )
152 {
153     va_list arg_ptr ;
154
155     gpg_log_print_prefix("");
156     va_start( arg_ptr, fmt ) ;
157     vfprintf(logfp,fmt,arg_ptr) ;
158     va_end(arg_ptr);
159     errorcount++;
160 }
161
162 void
163 gpg_log_error_f( const char *fname, const char *fmt, ... )
164 {
165     va_list arg_ptr ;
166
167     print_prefix_f("", fname);
168     va_start( arg_ptr, fmt ) ;
169     vfprintf(logfp,fmt,arg_ptr) ;
170     va_end(arg_ptr);
171     errorcount++;
172 }
173
174 void
175 gpg_log_fatal( const char *fmt, ... )
176 {
177     va_list arg_ptr ;
178
179     gpg_log_print_prefix("fatal: ");
180     va_start( arg_ptr, fmt ) ;
181     vfprintf(logfp,fmt,arg_ptr) ;
182     va_end(arg_ptr);
183     secmem_dump_stats();
184     exit(2);
185 }
186
187 void
188 gpg_log_fatal_f( const char *fname, const char *fmt, ... )
189 {
190     va_list arg_ptr ;
191
192     print_prefix_f("fatal: ", fname);
193     va_start( arg_ptr, fmt ) ;
194     vfprintf(logfp,fmt,arg_ptr) ;
195     va_end(arg_ptr);
196     secmem_dump_stats();
197     exit(2);
198 }
199
200 void
201 gpg_log_bug( const char *fmt, ... )
202 {
203     va_list arg_ptr ;
204
205     putc('\n', stderr );
206     gpg_log_print_prefix("Ohhhh jeeee: ");
207     va_start( arg_ptr, fmt ) ;
208     vfprintf(stderr,fmt,arg_ptr) ;
209     va_end(arg_ptr);
210     fflush(stderr);
211     secmem_dump_stats();
212     abort();
213 }
214
215 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 )
216 void
217 gpg_log_bug0( const char *file, int line, const char *func )
218 {
219     log_bug(_("... this is a bug (%s:%d:%s)\n"), file, line, func );
220 }
221 #else
222 void
223 gpg_log_bug0( const char *file, int line )
224 {
225     log_bug(_("you found a bug ... (%s:%d)\n"), file, line);
226 }
227 #endif
228
229 void
230 gpg_log_debug( const char *fmt, ... )
231 {
232     va_list arg_ptr ;
233
234     gpg_log_print_prefix("DBG: ");
235     va_start( arg_ptr, fmt ) ;
236     vfprintf(logfp,fmt,arg_ptr) ;
237     va_end(arg_ptr);
238 }
239
240 void
241 gpg_log_debug_f( const char *fname, const char *fmt, ... )
242 {
243     va_list arg_ptr ;
244
245     print_prefix_f("DBG: ", fname);
246     va_start( arg_ptr, fmt ) ;
247     vfprintf(logfp,fmt,arg_ptr) ;
248     va_end(arg_ptr);
249 }
250
251
252
253 void
254 gpg_log_hexdump( const char *text, const char *buf, size_t len )
255 {
256     int i;
257
258     gpg_log_print_prefix(text);
259     for(i=0; i < len; i++ )
260         fprintf(logfp, " %02X", ((const byte*)buf)[i] );
261     fputc('\n', logfp);
262 }
263
264
265