1: /*
2: * BIRD Library -- Logging Functions
3: *
4: * (c) 1998--2000 Martin Mares <mj@ucw.cz>
5: *
6: * Can be freely distributed and used under the terms of the GNU GPL.
7: */
8:
9: /**
10: * DOC: Logging
11: *
12: * The Logging module offers a simple set of functions for writing
13: * messages to system logs and to the debug output. Message classes
14: * used by this module are described in |birdlib.h| and also in the
15: * user's manual.
16: */
17:
18: #include <stdio.h>
19: #include <stdlib.h>
20: #include <stdarg.h>
21: #include <time.h>
22: #include <sys/types.h>
23: #include <sys/stat.h>
24: #include <unistd.h>
25: #include <errno.h>
26:
27: #include "nest/bird.h"
28: #include "nest/cli.h"
29: #include "conf/conf.h"
30: #include "lib/string.h"
31: #include "lib/lists.h"
32: #include "sysdep/unix/unix.h"
33:
34: static FILE *dbgf;
35: static list *current_log_list;
36: static char *current_syslog_name; /* NULL -> syslog closed */
37:
38:
39: #ifdef USE_PTHREADS
40:
41: #include <pthread.h>
42:
43: static pthread_mutex_t log_mutex;
44: static inline void log_lock(void) { pthread_mutex_lock(&log_mutex); }
45: static inline void log_unlock(void) { pthread_mutex_unlock(&log_mutex); }
46:
47: static pthread_t main_thread;
48: void main_thread_init(void) { main_thread = pthread_self(); }
49: static int main_thread_self(void) { return pthread_equal(pthread_self(), main_thread); }
50:
51: #else
52:
53: static inline void log_lock(void) { }
54: static inline void log_unlock(void) { }
55: void main_thread_init(void) { }
56: static int main_thread_self(void) { return 1; }
57:
58: #endif
59:
60:
61: #ifdef HAVE_SYSLOG_H
62: #include <sys/syslog.h>
63:
64: static int syslog_priorities[] = {
65: LOG_DEBUG,
66: LOG_DEBUG,
67: LOG_DEBUG,
68: LOG_INFO,
69: LOG_ERR,
70: LOG_WARNING,
71: LOG_ERR,
72: LOG_ERR,
73: LOG_CRIT,
74: LOG_CRIT
75: };
76: #endif
77:
78: static char *class_names[] = {
79: "???",
80: "DBG",
81: "TRACE",
82: "INFO",
83: "RMT",
84: "WARN",
85: "ERR",
86: "AUTH",
87: "FATAL",
88: "BUG"
89: };
90:
91: static inline off_t
92: log_size(struct log_config *l)
93: {
94: struct stat st;
95: return (!fstat(rf_fileno(l->rf), &st) && S_ISREG(st.st_mode)) ? st.st_size : 0;
96: }
97:
98: static void
99: log_close(struct log_config *l)
100: {
101: rfree(l->rf);
102: l->rf = NULL;
103: l->fh = NULL;
104: }
105:
106: static int
107: log_open(struct log_config *l)
108: {
109: l->rf = rf_open(config->pool, l->filename, "a");
110: if (!l->rf)
111: {
112: /* Well, we cannot do much in case of error as log is closed */
113: l->mask = 0;
114: return -1;
115: }
116:
117: l->fh = rf_file(l->rf);
118: l->pos = log_size(l);
119:
120: return 0;
121: }
122:
123: static int
124: log_rotate(struct log_config *l)
125: {
126: log_close(l);
127:
128: /* If we cannot rename the logfile, we at least try to delete it
129: in order to continue logging and not exceeding logfile size */
130: if ((rename(l->filename, l->backup) < 0) &&
131: (unlink(l->filename) < 0))
132: {
133: l->mask = 0;
134: return -1;
135: }
136:
137: return log_open(l);
138: }
139:
140: /**
141: * log_commit - commit a log message
142: * @class: message class information (%L_DEBUG to %L_BUG, see |lib/birdlib.h|)
143: * @buf: message to write
144: *
145: * This function writes a message prepared in the log buffer to the
146: * log file (as specified in the configuration). The log buffer is
147: * reset after that. The log message is a full line, log_commit()
148: * terminates it.
149: *
150: * The message class is an integer, not a first char of a string like
151: * in log(), so it should be written like *L_INFO.
152: */
153: void
154: log_commit(int class, buffer *buf)
155: {
156: struct log_config *l;
157:
158: if (buf->pos == buf->end)
159: strcpy(buf->end - 100, " ... <too long>");
160:
161: log_lock();
162: WALK_LIST(l, *current_log_list)
163: {
164: if (!(l->mask & (1 << class)))
165: continue;
166: if (l->fh)
167: {
168: if (l->terminal_flag)
169: fputs("bird: ", l->fh);
170: else
171: {
172: byte tbuf[TM_DATETIME_BUFFER_SIZE];
173: const char *fmt = config ? config->tf_log.fmt1 : "%F %T.%3f";
174: if (!tm_format_real_time(tbuf, sizeof(tbuf), fmt, current_real_time()))
175: strcpy(tbuf, "<error>");
176:
177: if (l->limit)
178: {
179: off_t msg_len = strlen(tbuf) + strlen(class_names[class]) +
180: (buf->pos - buf->start) + 5;
181:
182: if (l->pos < 0)
183: l->pos = log_size(l);
184:
185: if (l->pos + msg_len > l->limit)
186: if (log_rotate(l) < 0)
187: continue;
188:
189: l->pos += msg_len;
190: }
191:
192: fprintf(l->fh, "%s <%s> ", tbuf, class_names[class]);
193: }
194: fputs(buf->start, l->fh);
195: fputc('\n', l->fh);
196: fflush(l->fh);
197: }
198: #ifdef HAVE_SYSLOG_H
199: else
200: syslog(syslog_priorities[class], "%s", buf->start);
201: #endif
202: }
203: log_unlock();
204:
205: /* cli_echo is not thread-safe, so call it just from the main thread */
206: if (main_thread_self())
207: cli_echo(class, buf->start);
208:
209: buf->pos = buf->start;
210: }
211:
212: int buffer_vprint(buffer *buf, const char *fmt, va_list args);
213:
214: static void
215: vlog(int class, const char *msg, va_list args)
216: {
217: buffer buf;
218: LOG_BUFFER_INIT(buf);
219: buffer_vprint(&buf, msg, args);
220: log_commit(class, &buf);
221: }
222:
223:
224: /**
225: * log - log a message
226: * @msg: printf-like formatting string with message class information
227: * prepended (%L_DEBUG to %L_BUG, see |lib/birdlib.h|)
228: *
229: * This function formats a message according to the format string @msg
230: * and writes it to the corresponding log file (as specified in the
231: * configuration). Please note that the message is automatically
232: * formatted as a full line, no need to include |\n| inside.
233: * It is essentially a sequence of log_reset(), logn() and log_commit().
234: */
235: void
236: log_msg(const char *msg, ...)
237: {
238: int class = 1;
239: va_list args;
240:
241: va_start(args, msg);
242: if (*msg >= 1 && *msg <= 8)
243: class = *msg++;
244: vlog(class, msg, args);
245: va_end(args);
246: }
247:
248: void
249: log_rl(struct tbf *f, const char *msg, ...)
250: {
251: int class = 1;
252: va_list args;
253:
254: /* Rate limiting is a bit tricky here as it also logs '...' during the first hit */
255: if (tbf_limit(f) && (f->drop > 1))
256: return;
257:
258: if (*msg >= 1 && *msg <= 8)
259: class = *msg++;
260:
261: va_start(args, msg);
262: vlog(class, (f->drop ? "..." : msg), args);
263: va_end(args);
264: }
265:
266: /**
267: * bug - report an internal error
268: * @msg: a printf-like error message
269: *
270: * This function logs an internal error and aborts execution
271: * of the program.
272: */
273: void
274: bug(const char *msg, ...)
275: {
276: va_list args;
277:
278: va_start(args, msg);
279: vlog(L_BUG[0], msg, args);
280: va_end(args);
281: abort();
282: }
283:
284: /**
285: * bug - report a fatal error
286: * @msg: a printf-like error message
287: *
288: * This function logs a fatal error and aborts execution
289: * of the program.
290: */
291: void
292: die(const char *msg, ...)
293: {
294: va_list args;
295:
296: va_start(args, msg);
297: vlog(L_FATAL[0], msg, args);
298: va_end(args);
299: exit(1);
300: }
301:
302: /**
303: * debug - write to debug output
304: * @msg: a printf-like message
305: *
306: * This function formats the message @msg and prints it out
307: * to the debugging output. No newline character is appended.
308: */
309: void
310: debug(const char *msg, ...)
311: {
312: #define MAX_DEBUG_BUFSIZE 65536
313: va_list args;
314: static uint bufsize = 4096;
315: static char *buf = NULL;
316:
317: if (!buf)
318: buf = mb_alloc(&root_pool, bufsize);
319:
320: va_start(args, msg);
321: if (dbgf)
322: {
323: while (bvsnprintf(buf, bufsize, msg, args) < 0)
324: if (bufsize >= MAX_DEBUG_BUFSIZE)
325: bug("Extremely long debug output, split it.");
326: else
327: buf = mb_realloc(buf, (bufsize *= 2));
328:
329: fputs(buf, dbgf);
330: }
331: va_end(args);
332: }
333:
334: static list *
335: default_log_list(int initial, char **syslog_name)
336: {
337: static list log_list;
338: init_list(&log_list);
339: *syslog_name = NULL;
340:
341: #ifdef HAVE_SYSLOG_H
342: if (!dbgf)
343: {
344: static struct log_config lc_syslog = { .mask = ~0 };
345: add_tail(&log_list, &lc_syslog.n);
346: *syslog_name = bird_name;
347: }
348: #endif
349:
350: if (dbgf && (dbgf != stderr))
351: {
352: static struct log_config lc_debug = { .mask = ~0 };
353: lc_debug.fh = dbgf;
354: add_tail(&log_list, &lc_debug.n);
355: }
356:
357: if (initial || (dbgf == stderr))
358: {
359: static struct log_config lc_stderr = { .mask = ~0, .terminal_flag = 1};
360: lc_stderr.fh = stderr;
361: add_tail(&log_list, &lc_stderr.n);
362: }
363:
364: return &log_list;
365: }
366:
367: void
368: log_switch(int initial, list *logs, char *new_syslog_name)
369: {
370: struct log_config *l;
371:
372: if (!logs || EMPTY_LIST(*logs))
373: logs = default_log_list(initial, &new_syslog_name);
374:
375: /* We shouldn't close the logs when other threads may use them */
376: log_lock();
377:
378: /* Close the logs to avoid pinning them on disk when deleted */
379: if (current_log_list)
380: WALK_LIST(l, *current_log_list)
381: if (l->rf)
382: log_close(l);
383:
384: /* Reopen the logs, needed for 'configure undo' */
385: if (logs)
386: WALK_LIST(l, *logs)
387: if (l->filename && !l->rf)
388: log_open(l);
389:
390: current_log_list = logs;
391:
392: #ifdef HAVE_SYSLOG_H
393: if (!bstrcmp(current_syslog_name, new_syslog_name))
394: goto done;
395:
396: if (current_syslog_name)
397: {
398: closelog();
399: xfree(current_syslog_name);
400: current_syslog_name = NULL;
401: }
402:
403: if (new_syslog_name)
404: {
405: current_syslog_name = xstrdup(new_syslog_name);
406: openlog(current_syslog_name, LOG_CONS | LOG_NDELAY, LOG_DAEMON);
407: }
408:
409: #endif
410:
411: done:
412: /* Logs exchange done, let the threads log as before */
413: log_unlock();
414: }
415:
416: void
417: log_init_debug(char *f)
418: {
419: if (dbgf && dbgf != stderr)
420: fclose(dbgf);
421: if (!f)
422: dbgf = NULL;
423: else if (!*f)
424: dbgf = stderr;
425: else if (!(dbgf = fopen(f, "a")))
426: {
427: /* Cannot use die() nor log() here, logging is not yet initialized */
428: fprintf(stderr, "bird: Unable to open debug file %s: %s\n", f, strerror(errno));
429: exit(1);
430: }
431: if (dbgf)
432: setvbuf(dbgf, NULL, _IONBF, 0);
433: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to log.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / sysdep / unix