Line data Source code
1 : #include "burp.h"
2 : #include "alloc.h"
3 : #include "asfd.h"
4 : #include "async.h"
5 : #include "cmd.h"
6 : #include "cntr.h"
7 : #include "iobuf.h"
8 : #include "log.h"
9 : #include "strlist.h"
10 : #include "times.h"
11 :
12 : const char *prog="unknown";
13 : const char *prog_long="unknown";
14 :
15 : static struct fzp *logfzp=NULL;
16 : // Start with all logging on, so that something is said when initial startup
17 : // goes wrong - for example, reading the conf file.
18 : static int do_syslog=1;
19 : static int do_stdout=1;
20 : static int do_progress_counter=1;
21 : static int force_quiet=0;
22 : static int syslog_opened=0;
23 : static int json=0;
24 :
25 0 : void log_init(char *progname)
26 : {
27 0 : prog_long=progname;
28 0 : if((prog=strrchr(progname, '/'))) prog++;
29 0 : else prog=progname;
30 0 : }
31 :
32 1384 : void logp(const char *fmt, ...)
33 : {
34 : #ifndef UTEST
35 : int pid;
36 : char buf[512]="";
37 : va_list ap;
38 : va_start(ap, fmt);
39 : vsnprintf(buf, sizeof(buf), fmt, ap);
40 : pid=(int)getpid();
41 : if(logfzp)
42 : fzp_printf(logfzp, "%s: %s[%d] %s",
43 : gettimenow(), prog, pid, buf);
44 : else
45 : {
46 : if(do_syslog)
47 : syslog(LOG_INFO, "%s", buf);
48 : if(do_stdout)
49 : {
50 : if(json)
51 : {
52 : char *cp;
53 : // To help programs parsing the monitor output,
54 : // log things with simple JSON.
55 : // So do simple character substitution to have
56 : // a better chance of valid JSON.
57 : for(cp=buf; *cp; cp++)
58 : {
59 : if(*cp=='"')
60 : *cp='\'';
61 : else if(!isprint(*cp))
62 : *cp='.';
63 : }
64 : fprintf(stdout, "{ \"logline\": \"%s\" }\n", buf);
65 : }
66 : else
67 : fprintf(stdout, "%s: %s[%d] %s",
68 : gettimenow(), prog, pid, buf);
69 : }
70 : }
71 : va_end(ap);
72 : #endif
73 1384 : }
74 :
75 0 : void logp_ssl_err(const char *fmt, ...)
76 : {
77 0 : char buf[512]="";
78 : va_list ap;
79 0 : va_start(ap, fmt);
80 : vsnprintf(buf, sizeof(buf), fmt, ap);
81 0 : va_end(ap);
82 : logp("%s", buf);
83 0 : if(logfzp) fzp_ERR_print_errors_fp(logfzp);
84 : else
85 : {
86 0 : if(do_syslog)
87 : {
88 : // FIX THIS: How to send to syslog?
89 : static BIO *bio_err=NULL;
90 0 : if(!bio_err) bio_err=BIO_new_fp(stderr, BIO_NOCLOSE);
91 0 : ERR_print_errors(bio_err);
92 : }
93 0 : if(do_stdout)
94 : {
95 0 : if(!json)
96 : {
97 : static BIO *bio_err=NULL;
98 0 : if(!bio_err) bio_err=BIO_new_fp(stdout,
99 : BIO_NOCLOSE);
100 0 : ERR_print_errors(bio_err);
101 : }
102 : }
103 : }
104 0 : }
105 :
106 : // For the counters.
107 0 : void logc(const char *fmt, ...)
108 : {
109 0 : char buf[512]="";
110 : va_list ap;
111 0 : va_start(ap, fmt);
112 : vsnprintf(buf, sizeof(buf), fmt, ap);
113 0 : if(logfzp)
114 0 : fzp_printf(logfzp, "%s", buf); // for the server side
115 : else
116 : {
117 0 : if(do_progress_counter
118 0 : && do_stdout)
119 0 : fprintf(stdout, "%s", buf);
120 : }
121 0 : va_end(ap);
122 0 : }
123 :
124 96 : void logfmt(const char *fmt, ...)
125 : {
126 : #ifndef UTEST
127 : if(do_stdout)
128 : {
129 : char buf[512]="";
130 : va_list ap;
131 : va_start(ap, fmt);
132 : vsnprintf(buf, sizeof(buf), fmt, ap);
133 : fprintf(stdout, "%s", buf);
134 : }
135 : #endif
136 96 : }
137 :
138 100 : const char *progname(void)
139 : {
140 100 : return prog;
141 : }
142 :
143 20 : int log_fzp_set(const char *path, struct conf **confs)
144 : {
145 20 : fzp_close(&logfzp);
146 20 : if(path)
147 : {
148 : logp("Logging to %s\n", path);
149 10 : if(!(logfzp=fzp_open(path, "ab"))) return -1;
150 : }
151 20 : if(logfzp) fzp_setlinebuf(logfzp);
152 20 : do_syslog=get_int(confs[OPT_SYSLOG]);
153 20 : if(force_quiet)
154 : {
155 0 : do_stdout=0;
156 0 : do_progress_counter=0;
157 : }
158 : else
159 : {
160 20 : do_stdout=get_int(confs[OPT_STDOUT]);
161 20 : do_progress_counter=get_int(confs[OPT_PROGRESS_COUNTER]);
162 : }
163 :
164 20 : if(syslog_opened)
165 : {
166 0 : closelog();
167 0 : syslog_opened=0;
168 : }
169 20 : if(do_syslog)
170 : {
171 0 : openlog(prog, LOG_PID, LOG_USER);
172 0 : syslog_opened++;
173 : }
174 : return 0;
175 : }
176 :
177 0 : void log_force_quiet(void)
178 : {
179 0 : force_quiet=1;
180 0 : }
181 :
182 0 : void log_fzp_set_direct(struct fzp *fzp)
183 : {
184 0 : fzp_close(&logfzp);
185 0 : logfzp=fzp;
186 0 : }
187 :
188 1 : void log_out_of_memory(const char *function)
189 : {
190 : if(function) logp("out of memory in %s()\n", function);
191 : else logp("out of memory in unknown function\n");
192 1 : }
193 :
194 9 : void log_restore_settings(struct conf **cconfs, int srestore)
195 : {
196 : struct strlist *l;
197 : logp("Restore settings:\n");
198 9 : if(get_string(cconfs[OPT_ORIG_CLIENT]))
199 1 : logp("orig_client = '%s'\n",
200 : get_string(cconfs[OPT_ORIG_CLIENT]));
201 9 : if(get_string(cconfs[OPT_BACKUP]))
202 9 : logp("backup = '%s'\n",
203 : get_string(cconfs[OPT_BACKUP]));
204 9 : if(srestore)
205 : {
206 : // This are unknown unless doing a server initiated restore.
207 2 : logp("overwrite = %d\n", get_int(cconfs[OPT_OVERWRITE]));
208 2 : logp("strip = %d\n", get_int(cconfs[OPT_STRIP]));
209 : }
210 9 : if(get_string(cconfs[OPT_RESTOREPREFIX]))
211 0 : logp("restoreprefix = '%s'\n",
212 : get_string(cconfs[OPT_RESTOREPREFIX]));
213 9 : if(get_string(cconfs[OPT_STRIP_FROM_PATH]))
214 0 : logp("stripfrompath = '%s'\n",
215 : get_string(cconfs[OPT_STRIP_FROM_PATH]));
216 9 : if(get_string(cconfs[OPT_REGEX]))
217 0 : logp("regex = '%s'\n", get_string(cconfs[OPT_REGEX]));
218 12 : for(l=get_strlist(cconfs[OPT_INCLUDE]); l; l=l->next)
219 3 : logp("include = '%s'\n", l->path);
220 9 : }
221 :
222 0 : int logm(struct asfd *asfd, struct conf **confs, const char *fmt, ...)
223 : {
224 0 : int r=0;
225 0 : char buf[512]="";
226 : va_list ap;
227 0 : va_start(ap, fmt);
228 : vsnprintf(buf, sizeof(buf), fmt, ap);
229 0 : if(asfd && asfd->as->doing_estimate) printf("\nMESSAGE: %s", buf);
230 : else
231 : {
232 0 : if(asfd
233 0 : && get_int(confs[OPT_MESSAGE])) // Backwards compatibility
234 0 : r=asfd->write_str(asfd, CMD_MESSAGE, buf);
235 : logp("MESSAGE: %s", buf);
236 : }
237 0 : va_end(ap);
238 0 : if(confs) cntr_add(get_cntr(confs), CMD_MESSAGE, 1);
239 0 : return r;
240 : }
241 :
242 14 : int logw(struct asfd *asfd, struct cntr *cntr, const char *fmt, ...)
243 : {
244 14 : int r=0;
245 14 : char buf[512]="";
246 : va_list ap;
247 14 : va_start(ap, fmt);
248 : vsnprintf(buf, sizeof(buf), fmt, ap);
249 14 : if(asfd
250 10 : && asfd->as
251 3 : && asfd->as->doing_estimate)
252 : printf("\nWARNING: %s", buf);
253 : else
254 : {
255 14 : if(asfd)
256 10 : r=asfd->write_str(asfd, CMD_WARNING, buf);
257 : logp("WARNING: %s", buf);
258 : }
259 14 : va_end(ap);
260 14 : cntr_add(cntr, CMD_WARNING, 1);
261 14 : return r;
262 : }
263 :
264 10 : void log_and_send(struct asfd *asfd, const char *msg)
265 : {
266 : logp("%s\n", msg);
267 10 : if(asfd)
268 10 : asfd->write_str(asfd, CMD_ERROR, msg);
269 10 : }
270 :
271 0 : void log_and_send_oom(struct asfd *asfd)
272 : {
273 0 : char m[256]="";
274 : snprintf(m, sizeof(m), "out of memory in %s()\n", __func__);
275 : logp("%s", m);
276 0 : if(asfd)
277 0 : asfd->write_str(asfd, CMD_ERROR, m);
278 0 : }
279 :
280 0 : void log_set_json(int value)
281 : {
282 0 : json=value;
283 0 : }
284 :
285 10 : void log_oom_w(const char *func, const char *orig_func)
286 : {
287 : logp("out of memory in %s, called from %s\n", func, orig_func);
288 10 : }
289 :
290 0 : int log_incexcs_buf(const char *incexc)
291 : {
292 0 : char *tok=NULL;
293 0 : char *copy=NULL;
294 0 : if(!incexc || !*incexc) return 0;
295 0 : if(!(copy=strdup_w(incexc, __func__)))
296 : return -1;
297 0 : if(!(tok=strtok(copy, "\n")))
298 : {
299 : logp("unable to parse server incexc\n");
300 0 : free_w(©);
301 0 : return -1;
302 : }
303 : do
304 : {
305 : logp("%s\n", tok);
306 0 : } while((tok=strtok(NULL, "\n")));
307 0 : free_w(©);
308 0 : return 0;
309 : }
310 :
311 8 : void log_recvd(struct iobuf *iobuf, struct cntr *cntr, int print)
312 : {
313 : int l;
314 8 : const char *prefix="unset";
315 : switch(iobuf->cmd)
316 : {
317 : case CMD_MESSAGE: prefix="MESSAGE"; break;
318 : case CMD_WARNING: prefix="WARNING"; break;
319 : default: break;
320 : }
321 : // Strip any trailing newlines.
322 9 : for(l=iobuf->len-1; l>=0; l--)
323 : {
324 9 : if(iobuf->buf[l]!='\n')
325 : break;
326 1 : iobuf->buf[l]='\0';
327 : }
328 8 : logp("%s: %s\n", prefix, iobuf->buf);
329 8 : cntr_add(cntr, iobuf->cmd, print);
330 8 : }
|
