blob: c55bfcb18d0da4d378f0ac1112a37375f39be918 [file] [log] [blame]
paul718e3742002-12-13 20:15:29 +00001/* Logging of zebra
2 * Copyright (C) 1997, 1998, 1999 Kunihiro Ishiguro
3 *
4 * This file is part of GNU Zebra.
5 *
6 * GNU Zebra is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
9 * later version.
10 *
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with GNU Zebra; see the file COPYING. If not, write to the Free
18 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
19 * 02111-1307, USA.
20 */
21
22#include <zebra.h>
23
24#include "log.h"
25#include "memory.h"
26#include "command.h"
27
28struct zlog *zlog_default = NULL;
29
30const char *zlog_proto_names[] =
31{
32 "NONE",
33 "DEFAULT",
34 "ZEBRA",
35 "RIP",
36 "BGP",
37 "OSPF",
38 "RIPNG",
39 "OSPF6",
jardin9e867fe2003-12-23 08:56:18 +000040 "ISIS",
paul718e3742002-12-13 20:15:29 +000041 "MASC",
42 NULL,
43};
44
45const char *zlog_priority[] =
46{
47 "emergencies",
48 "alerts",
49 "critical",
50 "errors",
51 "warnings",
52 "notifications",
53 "informational",
54 "debugging",
55 NULL,
56};
57
58
59
60/* For time string format. */
61#define TIME_BUF 27
62
63/* Utility routine for current time printing. */
64static void
65time_print (FILE *fp)
66{
67 int ret;
68 char buf [TIME_BUF];
69 time_t clock;
70 struct tm *tm;
71
72 time (&clock);
73 tm = localtime (&clock);
74
75 ret = strftime (buf, TIME_BUF, "%Y/%m/%d %H:%M:%S", tm);
76 if (ret == 0) {
77 zlog_warn ("strftime error");
78 }
79
80 fprintf (fp, "%s ", buf);
81}
82
83/* va_list version of zlog. */
ajsd246bd92004-11-23 17:35:08 +000084static void
85vzlog (struct zlog *zl, int priority, const char *format, va_list args)
paul718e3742002-12-13 20:15:29 +000086{
87 /* If zlog is not specified, use default one. */
88 if (zl == NULL)
89 zl = zlog_default;
90
91 /* When zlog_default is also NULL, use stderr for logging. */
92 if (zl == NULL)
93 {
94 time_print (stderr);
95 fprintf (stderr, "%s: ", "unknown");
ajsd246bd92004-11-23 17:35:08 +000096 vfprintf (stderr, format, args);
paul718e3742002-12-13 20:15:29 +000097 fprintf (stderr, "\n");
98 fflush (stderr);
99
100 /* In this case we return at here. */
101 return;
102 }
103
104 /* only log this information if it has not been masked out */
105 if ( priority > zl->maskpri )
106 return ;
107
108 /* Syslog output */
109 if (zl->flags & ZLOG_SYSLOG)
ajsd246bd92004-11-23 17:35:08 +0000110 {
111 va_list ac;
112 va_copy(ac, args);
113 vsyslog (priority|zlog_default->facility, format, ac);
114 va_end(ac);
115 }
paul718e3742002-12-13 20:15:29 +0000116
117 /* File output. */
118 if (zl->flags & ZLOG_FILE)
119 {
ajsd246bd92004-11-23 17:35:08 +0000120 va_list ac;
paul718e3742002-12-13 20:15:29 +0000121 time_print (zl->fp);
hassob04c6992004-10-04 19:10:31 +0000122 if (zl->record_priority)
123 fprintf (zl->fp, "%s: ", zlog_priority[priority]);
paul718e3742002-12-13 20:15:29 +0000124 fprintf (zl->fp, "%s: ", zlog_proto_names[zl->protocol]);
ajsd246bd92004-11-23 17:35:08 +0000125 va_copy(ac, args);
126 vfprintf (zl->fp, format, ac);
127 va_end(ac);
paul718e3742002-12-13 20:15:29 +0000128 fprintf (zl->fp, "\n");
129 fflush (zl->fp);
130 }
131
132 /* stdout output. */
133 if (zl->flags & ZLOG_STDOUT)
134 {
ajsd246bd92004-11-23 17:35:08 +0000135 va_list ac;
paul718e3742002-12-13 20:15:29 +0000136 time_print (stdout);
hassob04c6992004-10-04 19:10:31 +0000137 if (zl->record_priority)
138 fprintf (stdout, "%s: ", zlog_priority[priority]);
paul718e3742002-12-13 20:15:29 +0000139 fprintf (stdout, "%s: ", zlog_proto_names[zl->protocol]);
ajsd246bd92004-11-23 17:35:08 +0000140 va_copy(ac, args);
141 vfprintf (stdout, format, ac);
142 va_end(ac);
paul718e3742002-12-13 20:15:29 +0000143 fprintf (stdout, "\n");
144 fflush (stdout);
145 }
146
147 /* stderr output. */
148 if (zl->flags & ZLOG_STDERR)
149 {
ajsd246bd92004-11-23 17:35:08 +0000150 va_list ac;
paul718e3742002-12-13 20:15:29 +0000151 time_print (stderr);
hassob04c6992004-10-04 19:10:31 +0000152 if (zl->record_priority)
153 fprintf (stderr, "%s: ", zlog_priority[priority]);
paul718e3742002-12-13 20:15:29 +0000154 fprintf (stderr, "%s: ", zlog_proto_names[zl->protocol]);
ajsd246bd92004-11-23 17:35:08 +0000155 va_copy(ac, args);
156 vfprintf (stderr, format, ac);
157 va_end(ac);
paul718e3742002-12-13 20:15:29 +0000158 fprintf (stderr, "\n");
159 fflush (stderr);
160 }
161
162 /* Terminal monitor. */
ajsd246bd92004-11-23 17:35:08 +0000163 vty_log (zlog_proto_names[zl->protocol], format, args);
paul718e3742002-12-13 20:15:29 +0000164}
165
ajs59a06a92004-11-23 18:19:14 +0000166static char *
167str_append(char *dst, int len, const char *src)
168{
169 while ((len-- > 0) && *src)
170 *dst++ = *src++;
171 return dst;
172}
173
174static char *
175num_append(char *s, int len, u_long x)
176{
177 char buf[30];
178 char *t = &buf[29];
179
180 *t = '\0';
181 while (x && (t > buf))
182 {
183 *--t = '0'+(x % 10);
184 x /= 10;
185 }
186 return str_append(s,len,t);
187}
188
189/* Note: the goal here is to use only async-signal-safe functions. */
190void
191zlog_signal(int signo, const char *action)
192{
193 time_t now;
194 char buf[sizeof("DEFAULT: Received signal S at T; aborting...")+60];
195 char *s = buf;
196
197#define LOC s,buf+sizeof(buf)-s
198
199 time(&now);
200 if (zlog_default)
201 {
202 s = str_append(LOC,zlog_proto_names[zlog_default->protocol]);
203 *s++ = ':';
204 *s++ = ' ';
205 }
206 s = str_append(LOC,"Received signal ");
207 s = num_append(LOC,signo);
208 s = str_append(LOC," at ");
209 s = num_append(LOC,now);
210 s = str_append(LOC,"; ");
211 s = str_append(LOC,action);
212 *s++ = '\n';
213
214#define DUMP(FP) write(fileno(FP),buf,s-buf);
215 if (!zlog_default)
216 DUMP(stderr)
217 else
218 {
219 if ((zlog_default->flags & ZLOG_FILE) && zlog_default->fp)
220 DUMP(zlog_default->fp)
221 if (zlog_default->flags & ZLOG_STDOUT)
222 DUMP(stdout)
223 if (zlog_default->flags & ZLOG_STDERR)
224 DUMP(stderr)
225 /* Is there a signal-safe way to send a syslog message? */
226 }
227#undef DUMP
228
229 /* Now try for a backtrace. */
230#ifdef HAVE_GLIBC_BACKTRACE
231 {
232 void *array[20];
233 size_t size;
234
235 size = backtrace(array,sizeof(array)/sizeof(array[0]));
236 s = buf;
237 s = str_append(LOC,"Backtrace for ");
238 s = num_append(LOC,size);
239 s = str_append(LOC," stack frames:\n");
240
241#define DUMP(FP) { \
242 write(fileno(FP),buf,s-buf); \
243 backtrace_symbols_fd(array, size, fileno(FP)); \
244}
245
246 if (!zlog_default)
247 DUMP(stderr)
248 else
249 {
250 if ((zlog_default->flags & ZLOG_FILE) && zlog_default->fp)
251 DUMP(zlog_default->fp)
252 if (zlog_default->flags & ZLOG_STDOUT)
253 DUMP(stdout)
254 if (zlog_default->flags & ZLOG_STDERR)
255 DUMP(stderr)
256 /* Is there a signal-safe way to send a syslog message? */
257 }
258#undef DUMP
259 }
260#endif /* HAVE_GLIBC_BACKTRACE */
261#undef LOC
262}
263
paul718e3742002-12-13 20:15:29 +0000264void
265zlog (struct zlog *zl, int priority, const char *format, ...)
266{
ajsd246bd92004-11-23 17:35:08 +0000267 va_list args;
paul718e3742002-12-13 20:15:29 +0000268
ajsd246bd92004-11-23 17:35:08 +0000269 va_start(args, format);
paul718e3742002-12-13 20:15:29 +0000270 vzlog (zl, priority, format, args);
ajsd246bd92004-11-23 17:35:08 +0000271 va_end (args);
paul718e3742002-12-13 20:15:29 +0000272}
273
ajsd246bd92004-11-23 17:35:08 +0000274#define ZLOG_FUNC(FUNCNAME,PRIORITY) \
275void \
276FUNCNAME(const char *format, ...) \
277{ \
278 va_list args; \
279 va_start(args, format); \
280 vzlog (NULL, PRIORITY, format, args); \
281 va_end(args); \
paul718e3742002-12-13 20:15:29 +0000282}
283
ajsd246bd92004-11-23 17:35:08 +0000284ZLOG_FUNC(zlog_err, LOG_ERR)
paul718e3742002-12-13 20:15:29 +0000285
ajsd246bd92004-11-23 17:35:08 +0000286ZLOG_FUNC(zlog_warn, LOG_WARNING)
paul718e3742002-12-13 20:15:29 +0000287
ajsd246bd92004-11-23 17:35:08 +0000288ZLOG_FUNC(zlog_info, LOG_INFO)
paul718e3742002-12-13 20:15:29 +0000289
ajsd246bd92004-11-23 17:35:08 +0000290ZLOG_FUNC(zlog_notice, LOG_NOTICE)
291
292ZLOG_FUNC(zlog_debug, LOG_DEBUG)
293
294#undef ZLOG_FUNC
295
296#define PLOG_FUNC(FUNCNAME,PRIORITY) \
297void \
298FUNCNAME(struct zlog *zl, const char *format, ...) \
299{ \
300 va_list args; \
301 va_start(args, format); \
302 vzlog (zl, PRIORITY, format, args); \
303 va_end(args); \
paul718e3742002-12-13 20:15:29 +0000304}
305
ajsd246bd92004-11-23 17:35:08 +0000306PLOG_FUNC(plog_err, LOG_ERR)
paul718e3742002-12-13 20:15:29 +0000307
ajsd246bd92004-11-23 17:35:08 +0000308PLOG_FUNC(plog_warn, LOG_WARNING)
paul718e3742002-12-13 20:15:29 +0000309
ajsd246bd92004-11-23 17:35:08 +0000310PLOG_FUNC(plog_info, LOG_INFO)
paul718e3742002-12-13 20:15:29 +0000311
ajsd246bd92004-11-23 17:35:08 +0000312PLOG_FUNC(plog_notice, LOG_NOTICE)
paul718e3742002-12-13 20:15:29 +0000313
ajsd246bd92004-11-23 17:35:08 +0000314PLOG_FUNC(plog_debug, LOG_DEBUG)
paul718e3742002-12-13 20:15:29 +0000315
ajsd246bd92004-11-23 17:35:08 +0000316#undef PLOG_FUNC
paul718e3742002-12-13 20:15:29 +0000317
318
319/* Open log stream */
320struct zlog *
321openzlog (const char *progname, int flags, zlog_proto_t protocol,
322 int syslog_flags, int syslog_facility)
323{
324 struct zlog *zl;
325
326 zl = XMALLOC(MTYPE_ZLOG, sizeof (struct zlog));
327 memset (zl, 0, sizeof (struct zlog));
328
329 zl->ident = progname;
330 zl->flags = flags;
331 zl->protocol = protocol;
332 zl->facility = syslog_facility;
333 zl->maskpri = LOG_DEBUG;
334 zl->record_priority = 0;
335
336 openlog (progname, syslog_flags, zl->facility);
337
338 return zl;
339}
340
341void
342closezlog (struct zlog *zl)
343{
344 closelog();
345 fclose (zl->fp);
346
347 XFREE (MTYPE_ZLOG, zl);
348}
349
350/* Called from command.c. */
351void
352zlog_set_flag (struct zlog *zl, int flags)
353{
354 if (zl == NULL)
355 zl = zlog_default;
356
357 zl->flags |= flags;
358}
359
360void
361zlog_reset_flag (struct zlog *zl, int flags)
362{
363 if (zl == NULL)
364 zl = zlog_default;
365
366 zl->flags &= ~flags;
367}
368
369int
ajsd246bd92004-11-23 17:35:08 +0000370zlog_set_file (struct zlog *zl, const char *filename)
paul718e3742002-12-13 20:15:29 +0000371{
372 FILE *fp;
gdtaa593d52003-12-22 20:15:53 +0000373 mode_t oldumask;
paul718e3742002-12-13 20:15:29 +0000374
375 /* There is opend file. */
376 zlog_reset_file (zl);
377
378 /* Set default zl. */
379 if (zl == NULL)
380 zl = zlog_default;
381
382 /* Open file. */
gdtaa593d52003-12-22 20:15:53 +0000383 oldumask = umask (0777 & ~LOGFILE_MASK);
paul718e3742002-12-13 20:15:29 +0000384 fp = fopen (filename, "a");
385 if (fp == NULL)
gdtaa593d52003-12-22 20:15:53 +0000386 {
387 umask(oldumask);
388 return 0;
389 }
390 umask(oldumask);
paul718e3742002-12-13 20:15:29 +0000391
392 /* Set flags. */
393 zl->filename = strdup (filename);
394 zl->flags |= ZLOG_FILE;
395 zl->fp = fp;
396
397 return 1;
398}
399
400/* Reset opend file. */
401int
402zlog_reset_file (struct zlog *zl)
403{
404 if (zl == NULL)
405 zl = zlog_default;
406
407 zl->flags &= ~ZLOG_FILE;
408
409 if (zl->fp)
410 fclose (zl->fp);
411 zl->fp = NULL;
412
413 if (zl->filename)
414 free (zl->filename);
415 zl->filename = NULL;
416
417 return 1;
418}
419
420/* Reopen log file. */
421int
422zlog_rotate (struct zlog *zl)
423{
424 FILE *fp;
425
426 if (zl == NULL)
427 zl = zlog_default;
428
429 if (zl->fp)
430 fclose (zl->fp);
431 zl->fp = NULL;
432
433 if (zl->filename)
434 {
gdtaa593d52003-12-22 20:15:53 +0000435 mode_t oldumask;
436
437 oldumask = umask (0777 & ~LOGFILE_MASK);
paul718e3742002-12-13 20:15:29 +0000438 fp = fopen (zl->filename, "a");
439 if (fp == NULL)
gdtaa593d52003-12-22 20:15:53 +0000440 {
441 umask(oldumask);
442 return -1;
443 }
444 umask(oldumask);
paul718e3742002-12-13 20:15:29 +0000445 zl->fp = fp;
446 }
447
448 return 1;
449}
450
paul718e3742002-12-13 20:15:29 +0000451/* Message lookup function. */
hasso8c328f12004-10-05 21:01:23 +0000452const char *
paul718e3742002-12-13 20:15:29 +0000453lookup (struct message *mes, int key)
454{
455 struct message *pnt;
456
457 for (pnt = mes; pnt->key != 0; pnt++)
458 if (pnt->key == key)
459 return pnt->str;
460
461 return "";
462}
463
464/* Very old hacky version of message lookup function. Still partly
hassob04c6992004-10-04 19:10:31 +0000465 used in bgpd and ospfd. FIXME Seems that it's not used any more. */
hasso8c328f12004-10-05 21:01:23 +0000466const char *
paul718e3742002-12-13 20:15:29 +0000467mes_lookup (struct message *meslist, int max, int index)
468{
469 if (index < 0 || index >= max)
470 {
471 zlog_err ("message index out of bound: %d", max);
472 return NULL;
473 }
474 return meslist[index].str;
475}
ajsca359762004-11-19 23:40:16 +0000476
477/* Wrapper around strerror to handle case where it returns NULL. */
478const char *
479safe_strerror(int errnum)
480{
481 const char *s = strerror(errnum);
482 return (s != NULL) ? s : "Unknown error";
483}