Obsolete option --no-sig-create-check.
[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 3 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, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <stdarg.h>
24 #include <string.h>
25 #include <errno.h>
26
27 #include "util.h"
28 #include "i18n.h"
29
30 #ifdef __VMS
31 # include <unistd.h>
32 # include "ttyio.h"
33 #endif /* def __VMS */
34
35 static char pidstring[15];
36 static char *pgm_name;
37 static int errorcount;
38 static int strict;
39 static FILE *logfp;
40
41 /****************
42  * Set the logfile to use (not yet implemneted) or, if logfile is NULL,
43  * the Fd where logoutputs should go.
44  */
45 void
46 log_set_logfile( const char *name, int fd )
47 {
48     if( name )
49         BUG();
50
51     if( logfp && logfp != stderr && logfp != stdout )
52         fclose( logfp );
53     if( fd == 1 )
54         logfp = stdout;
55     else if( fd == 2 )
56         logfp = stderr;
57     else
58         logfp = fdopen( fd, "a" );
59     if( !logfp ) {
60         logfp = stderr;
61         log_fatal("can't open fd %d for logging: %s\n", fd, strerror(errno));
62     }
63 }
64
65 FILE *
66 log_stream()
67 {
68     if( !logfp )
69         logfp = stderr;
70     return logfp;
71 }
72
73
74 void
75 log_set_name( const char *name )
76 {
77     xfree(pgm_name);
78     if( name )
79         pgm_name = xstrdup(name);
80     else
81         pgm_name = NULL;
82 }
83
84 const char *
85 log_get_name(void)
86 {
87     return pgm_name? pgm_name : "";
88 }
89
90
91 void
92 log_set_pid( int pid )
93 {
94     if( pid )
95         sprintf(pidstring,"[%u]", (unsigned)pid );
96     else
97         *pidstring = 0;
98 }
99
100 int
101 log_get_errorcount( int clear)
102 {
103     int n = errorcount;
104     if( clear )
105         errorcount = 0;
106     return n;
107 }
108
109 void
110 log_inc_errorcount()
111 {
112     errorcount++;
113 }
114
115 int
116 log_set_strict(int val)
117 {
118   int old=strict;
119   strict=val;
120   return old;
121 }
122
123 void
124 g10_log_print_prefix(const char *text)
125 {
126 #ifdef __VMS
127     /* 2006-08-10 SMS.
128        VMS terminal carriage control differs from that on UNIX, and one
129        result is overwritten messages when terminal output is done
130        through multiple file pointers (like logfp and ttyfp), even when
131        they both are connected to the same terminal.  The accomodation
132        attempted here is to initialize ttyfp before logfp, and if stderr
133        and ttyfp are both terminals (presumably the same one), to set an
134        unset logfp to ttyfp instead of to stderr.  */
135     if (!logfp )
136       {
137         FILE *ttyfp_local;
138         
139         init_ttyfp();
140         ttyfp_local = ttyfp_is ();
141         if (isatty (fileno (stderr)) && isatty (fileno (ttyfp_local)))
142           {
143             logfp = ttyfp_local;
144           }
145       }
146 #endif /* def __VMS */
147
148     if( !logfp )
149         logfp = stderr;
150     if( pgm_name )
151         fprintf(logfp, "%s%s: %s", pgm_name, pidstring, text );
152     else
153         fprintf(logfp, "?%s: %s", pidstring, text );
154 #ifdef __riscos__
155     fflush( logfp );
156 #endif /* __riscos__ */
157 }
158
159
160 void
161 g10_log_info( const char *fmt, ... )
162 {
163     va_list arg_ptr ;
164
165     g10_log_print_prefix("");
166     va_start( arg_ptr, fmt ) ;
167     vfprintf(logfp,fmt,arg_ptr) ;
168     va_end(arg_ptr);
169 #ifdef __riscos__
170     fflush( logfp );
171 #endif /* __riscos__ */
172 }
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
213 void
214 g10_log_fatal( const char *fmt, ... )
215 {
216     va_list arg_ptr ;
217
218     g10_log_print_prefix("fatal: ");
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
274
275 void
276 g10_log_hexdump( const char *text, const char *buf, size_t len )
277 {
278     int i;
279
280     g10_log_print_prefix(text);
281     for(i=0; i < len; i++ )
282         fprintf(logfp, " %02X", ((const byte*)buf)[i] );
283     fputc('\n', logfp);
284 #ifdef __riscos__
285     fflush( logfp );
286 #endif /* __riscos__ */
287 }
288
289
290