*** empty log message ***
[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
26 #include "util.h"
27
28 static char pidstring[15];
29 static char *pgm_name;
30 static int errorcount;
31
32 void
33 log_set_name( const char *name )
34 {
35     m_free(pgm_name);
36     if( name )
37         pgm_name = m_strdup(name);
38     else
39         pgm_name = NULL;
40 }
41
42 const char *
43 log_get_name(void)
44 {
45     return pgm_name? pgm_name : "";
46 }
47
48
49 void
50 log_set_pid( int pid )
51 {
52     if( pid )
53         sprintf(pidstring,"[%u]", (unsigned)pid );
54     else
55         *pidstring = 0;
56 }
57
58 int
59 log_get_errorcount( int clear)
60 {
61     int n = errorcount;
62     if( clear )
63         errorcount = 0;
64     return n;
65 }
66
67 static void
68 print_prefix(const char *text)
69 {
70     if( pgm_name )
71         fprintf(stderr, "%s%s: %s", pgm_name, pidstring, text );
72     else
73         fprintf(stderr, "?%s: %s", pidstring, text );
74 }
75
76 static void
77 print_prefix_f(const char *text, const char *fname)
78 {
79     if( pgm_name )
80         fprintf(stderr, "%s%s:%s: %s", pgm_name, pidstring, fname, text );
81     else
82         fprintf(stderr, "?%s:%s: %s", pidstring, fname, text );
83 }
84
85 void
86 g10_log_info( const char *fmt, ... )
87 {
88     va_list arg_ptr ;
89
90     print_prefix("");
91     va_start( arg_ptr, fmt ) ;
92     vfprintf(stderr,fmt,arg_ptr) ;
93     va_end(arg_ptr);
94 }
95
96 void
97 g10_log_info_f( const char *fname, const char *fmt, ... )
98 {
99     va_list arg_ptr ;
100
101     print_prefix_f("", fname);
102     va_start( arg_ptr, fmt ) ;
103     vfprintf(stderr,fmt,arg_ptr) ;
104     va_end(arg_ptr);
105 }
106
107 void
108 g10_log_error( const char *fmt, ... )
109 {
110     va_list arg_ptr ;
111
112     print_prefix("");
113     va_start( arg_ptr, fmt ) ;
114     vfprintf(stderr,fmt,arg_ptr) ;
115     va_end(arg_ptr);
116     errorcount++;
117 }
118
119 void
120 g10_log_error_f( const char *fname, const char *fmt, ... )
121 {
122     va_list arg_ptr ;
123
124     print_prefix_f("", fname);
125     va_start( arg_ptr, fmt ) ;
126     vfprintf(stderr,fmt,arg_ptr) ;
127     va_end(arg_ptr);
128     errorcount++;
129 }
130
131 void
132 g10_log_fatal( const char *fmt, ... )
133 {
134     va_list arg_ptr ;
135
136     print_prefix("fatal: ");
137     va_start( arg_ptr, fmt ) ;
138     vfprintf(stderr,fmt,arg_ptr) ;
139     va_end(arg_ptr);
140     secmem_dump_stats();
141     exit(2);
142 }
143
144 void
145 g10_log_fatal_f( const char *fname, const char *fmt, ... )
146 {
147     va_list arg_ptr ;
148
149     print_prefix_f("fatal: ", fname);
150     va_start( arg_ptr, fmt ) ;
151     vfprintf(stderr,fmt,arg_ptr) ;
152     va_end(arg_ptr);
153     secmem_dump_stats();
154     exit(2);
155 }
156
157 void
158 g10_log_bug( const char *fmt, ... )
159 {
160     va_list arg_ptr ;
161
162     putc('\n', stderr );
163     print_prefix("Ooops: ");
164     va_start( arg_ptr, fmt ) ;
165     vfprintf(stderr,fmt,arg_ptr) ;
166     va_end(arg_ptr);
167     fflush(stderr);
168     secmem_dump_stats();
169     abort();
170 }
171
172 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 )
173 void
174 g10_log_bug0( const char *file, int line, const char *func )
175 {
176     log_bug("you found a bug ... (%s:%d:%s)\n", file, line, func );
177 }
178 #else
179 void
180 g10_log_bug0( const char *file, int line )
181 {
182     log_bug("you found a bug ... (%s:%d)\n", file, line);
183 }
184 #endif
185
186 void
187 g10_log_debug( const char *fmt, ... )
188 {
189     va_list arg_ptr ;
190
191     print_prefix("DBG: ");
192     va_start( arg_ptr, fmt ) ;
193     vfprintf(stderr,fmt,arg_ptr) ;
194     va_end(arg_ptr);
195 }
196
197 void
198 g10_log_debug_f( const char *fname, const char *fmt, ... )
199 {
200     va_list arg_ptr ;
201
202     print_prefix_f("DBG: ", fname);
203     va_start( arg_ptr, fmt ) ;
204     vfprintf(stderr,fmt,arg_ptr) ;
205     va_end(arg_ptr);
206 }
207
208
209
210 void
211 g10_log_hexdump( const char *text, char *buf, size_t len )
212 {
213     int i;
214
215     print_prefix(text);
216     for(i=0; i < len; i++ )
217         fprintf(stderr, " %02X", ((byte*)buf)[i] );
218     fputc('\n', stderr);
219 }
220
221
222 void
223 g10_log_mpidump( const char *text, MPI a )
224 {
225     print_prefix(text);
226     mpi_print(stderr, a, 1 );
227     fputc('\n', stderr);
228 }
229