Annotation of embedaddon/quagga/lib/log.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Logging of zebra
! 3: * Copyright (C) 1997, 1998, 1999 Kunihiro Ishiguro
! 4: *
! 5: * This file is part of GNU Zebra.
! 6: *
! 7: * GNU Zebra is free software; you can redistribute it and/or modify it
! 8: * under the terms of the GNU General Public License as published by the
! 9: * Free Software Foundation; either version 2, or (at your option) any
! 10: * later version.
! 11: *
! 12: * GNU Zebra is distributed in the hope that it will be useful, but
! 13: * WITHOUT ANY WARRANTY; without even the implied warranty of
! 14: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
! 15: * General Public License for more details.
! 16: *
! 17: * You should have received a copy of the GNU General Public License
! 18: * along with GNU Zebra; see the file COPYING. If not, write to the Free
! 19: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
! 20: * 02111-1307, USA.
! 21: */
! 22:
! 23: #include <zebra.h>
! 24:
! 25: #include "log.h"
! 26: #include "memory.h"
! 27: #include "command.h"
! 28: #ifndef SUNOS_5
! 29: #include <sys/un.h>
! 30: #endif
! 31: /* for printstack on solaris */
! 32: #ifdef HAVE_UCONTEXT_H
! 33: #include <ucontext.h>
! 34: #endif
! 35:
! 36: static int logfile_fd = -1; /* Used in signal handler. */
! 37:
! 38: struct zlog *zlog_default = NULL;
! 39:
! 40: const char *zlog_proto_names[] =
! 41: {
! 42: "NONE",
! 43: "DEFAULT",
! 44: "ZEBRA",
! 45: "RIP",
! 46: "BGP",
! 47: "OSPF",
! 48: "RIPNG",
! 49: "OSPF6",
! 50: "ISIS",
! 51: "MASC",
! 52: NULL,
! 53: };
! 54:
! 55: const char *zlog_priority[] =
! 56: {
! 57: "emergencies",
! 58: "alerts",
! 59: "critical",
! 60: "errors",
! 61: "warnings",
! 62: "notifications",
! 63: "informational",
! 64: "debugging",
! 65: NULL,
! 66: };
! 67:
! 68:
! 69:
! 70: /* For time string format. */
! 71:
! 72: size_t
! 73: quagga_timestamp(int timestamp_precision, char *buf, size_t buflen)
! 74: {
! 75: static struct {
! 76: time_t last;
! 77: size_t len;
! 78: char buf[28];
! 79: } cache;
! 80: struct timeval clock;
! 81:
! 82: /* would it be sufficient to use global 'recent_time' here? I fear not... */
! 83: gettimeofday(&clock, NULL);
! 84:
! 85: /* first, we update the cache if the time has changed */
! 86: if (cache.last != clock.tv_sec)
! 87: {
! 88: struct tm *tm;
! 89: cache.last = clock.tv_sec;
! 90: tm = localtime(&cache.last);
! 91: cache.len = strftime(cache.buf, sizeof(cache.buf),
! 92: "%Y/%m/%d %H:%M:%S", tm);
! 93: }
! 94: /* note: it's not worth caching the subsecond part, because
! 95: chances are that back-to-back calls are not sufficiently close together
! 96: for the clock not to have ticked forward */
! 97:
! 98: if (buflen > cache.len)
! 99: {
! 100: memcpy(buf, cache.buf, cache.len);
! 101: if ((timestamp_precision > 0) &&
! 102: (buflen > cache.len+1+timestamp_precision))
! 103: {
! 104: /* should we worry about locale issues? */
! 105: static const int divisor[] = {0, 100000, 10000, 1000, 100, 10, 1};
! 106: int prec;
! 107: char *p = buf+cache.len+1+(prec = timestamp_precision);
! 108: *p-- = '\0';
! 109: while (prec > 6)
! 110: /* this is unlikely to happen, but protect anyway */
! 111: {
! 112: *p-- = '0';
! 113: prec--;
! 114: }
! 115: clock.tv_usec /= divisor[prec];
! 116: do
! 117: {
! 118: *p-- = '0'+(clock.tv_usec % 10);
! 119: clock.tv_usec /= 10;
! 120: }
! 121: while (--prec > 0);
! 122: *p = '.';
! 123: return cache.len+1+timestamp_precision;
! 124: }
! 125: buf[cache.len] = '\0';
! 126: return cache.len;
! 127: }
! 128: if (buflen > 0)
! 129: buf[0] = '\0';
! 130: return 0;
! 131: }
! 132:
! 133: /* Utility routine for current time printing. */
! 134: static void
! 135: time_print(FILE *fp, struct timestamp_control *ctl)
! 136: {
! 137: if (!ctl->already_rendered)
! 138: {
! 139: ctl->len = quagga_timestamp(ctl->precision, ctl->buf, sizeof(ctl->buf));
! 140: ctl->already_rendered = 1;
! 141: }
! 142: fprintf(fp, "%s ", ctl->buf);
! 143: }
! 144:
! 145:
! 146: /* va_list version of zlog. */
! 147: static void
! 148: vzlog (struct zlog *zl, int priority, const char *format, va_list args)
! 149: {
! 150: struct timestamp_control tsctl;
! 151: tsctl.already_rendered = 0;
! 152:
! 153: /* If zlog is not specified, use default one. */
! 154: if (zl == NULL)
! 155: zl = zlog_default;
! 156:
! 157: /* When zlog_default is also NULL, use stderr for logging. */
! 158: if (zl == NULL)
! 159: {
! 160: tsctl.precision = 0;
! 161: time_print(stderr, &tsctl);
! 162: fprintf (stderr, "%s: ", "unknown");
! 163: vfprintf (stderr, format, args);
! 164: fprintf (stderr, "\n");
! 165: fflush (stderr);
! 166:
! 167: /* In this case we return at here. */
! 168: return;
! 169: }
! 170: tsctl.precision = zl->timestamp_precision;
! 171:
! 172: /* Syslog output */
! 173: if (priority <= zl->maxlvl[ZLOG_DEST_SYSLOG])
! 174: {
! 175: va_list ac;
! 176: va_copy(ac, args);
! 177: vsyslog (priority|zlog_default->facility, format, ac);
! 178: va_end(ac);
! 179: }
! 180:
! 181: /* File output. */
! 182: if ((priority <= zl->maxlvl[ZLOG_DEST_FILE]) && zl->fp)
! 183: {
! 184: va_list ac;
! 185: time_print (zl->fp, &tsctl);
! 186: if (zl->record_priority)
! 187: fprintf (zl->fp, "%s: ", zlog_priority[priority]);
! 188: fprintf (zl->fp, "%s: ", zlog_proto_names[zl->protocol]);
! 189: va_copy(ac, args);
! 190: vfprintf (zl->fp, format, ac);
! 191: va_end(ac);
! 192: fprintf (zl->fp, "\n");
! 193: fflush (zl->fp);
! 194: }
! 195:
! 196: /* stdout output. */
! 197: if (priority <= zl->maxlvl[ZLOG_DEST_STDOUT])
! 198: {
! 199: va_list ac;
! 200: time_print (stdout, &tsctl);
! 201: if (zl->record_priority)
! 202: fprintf (stdout, "%s: ", zlog_priority[priority]);
! 203: fprintf (stdout, "%s: ", zlog_proto_names[zl->protocol]);
! 204: va_copy(ac, args);
! 205: vfprintf (stdout, format, ac);
! 206: va_end(ac);
! 207: fprintf (stdout, "\n");
! 208: fflush (stdout);
! 209: }
! 210:
! 211: /* Terminal monitor. */
! 212: if (priority <= zl->maxlvl[ZLOG_DEST_MONITOR])
! 213: vty_log ((zl->record_priority ? zlog_priority[priority] : NULL),
! 214: zlog_proto_names[zl->protocol], format, &tsctl, args);
! 215: }
! 216:
! 217: static char *
! 218: str_append(char *dst, int len, const char *src)
! 219: {
! 220: while ((len-- > 0) && *src)
! 221: *dst++ = *src++;
! 222: return dst;
! 223: }
! 224:
! 225: static char *
! 226: num_append(char *s, int len, u_long x)
! 227: {
! 228: char buf[30];
! 229: char *t;
! 230:
! 231: if (!x)
! 232: return str_append(s,len,"0");
! 233: *(t = &buf[sizeof(buf)-1]) = '\0';
! 234: while (x && (t > buf))
! 235: {
! 236: *--t = '0'+(x % 10);
! 237: x /= 10;
! 238: }
! 239: return str_append(s,len,t);
! 240: }
! 241:
! 242: #if defined(SA_SIGINFO) || defined(HAVE_STACK_TRACE)
! 243: static char *
! 244: hex_append(char *s, int len, u_long x)
! 245: {
! 246: char buf[30];
! 247: char *t;
! 248:
! 249: if (!x)
! 250: return str_append(s,len,"0");
! 251: *(t = &buf[sizeof(buf)-1]) = '\0';
! 252: while (x && (t > buf))
! 253: {
! 254: u_int cc = (x % 16);
! 255: *--t = ((cc < 10) ? ('0'+cc) : ('a'+cc-10));
! 256: x /= 16;
! 257: }
! 258: return str_append(s,len,t);
! 259: }
! 260: #endif
! 261:
! 262: /* Needs to be enhanced to support Solaris. */
! 263: static int
! 264: syslog_connect(void)
! 265: {
! 266: #ifdef SUNOS_5
! 267: return -1;
! 268: #else
! 269: int fd;
! 270: char *s;
! 271: struct sockaddr_un addr;
! 272:
! 273: if ((fd = socket(AF_UNIX,SOCK_DGRAM,0)) < 0)
! 274: return -1;
! 275: addr.sun_family = AF_UNIX;
! 276: #ifdef _PATH_LOG
! 277: #define SYSLOG_SOCKET_PATH _PATH_LOG
! 278: #else
! 279: #define SYSLOG_SOCKET_PATH "/dev/log"
! 280: #endif
! 281: s = str_append(addr.sun_path,sizeof(addr.sun_path),SYSLOG_SOCKET_PATH);
! 282: #undef SYSLOG_SOCKET_PATH
! 283: *s = '\0';
! 284: if (connect(fd,(struct sockaddr *)&addr,sizeof(addr)) < 0)
! 285: {
! 286: close(fd);
! 287: return -1;
! 288: }
! 289: return fd;
! 290: #endif
! 291: }
! 292:
! 293: static void
! 294: syslog_sigsafe(int priority, const char *msg, size_t msglen)
! 295: {
! 296: static int syslog_fd = -1;
! 297: char buf[sizeof("<1234567890>ripngd[1234567890]: ")+msglen+50];
! 298: char *s;
! 299:
! 300: if ((syslog_fd < 0) && ((syslog_fd = syslog_connect()) < 0))
! 301: return;
! 302:
! 303: #define LOC s,buf+sizeof(buf)-s
! 304: s = buf;
! 305: s = str_append(LOC,"<");
! 306: s = num_append(LOC,priority);
! 307: s = str_append(LOC,">");
! 308: /* forget about the timestamp, too difficult in a signal handler */
! 309: s = str_append(LOC,zlog_default->ident);
! 310: if (zlog_default->syslog_options & LOG_PID)
! 311: {
! 312: s = str_append(LOC,"[");
! 313: s = num_append(LOC,getpid());
! 314: s = str_append(LOC,"]");
! 315: }
! 316: s = str_append(LOC,": ");
! 317: s = str_append(LOC,msg);
! 318: write(syslog_fd,buf,s-buf);
! 319: #undef LOC
! 320: }
! 321:
! 322: static int
! 323: open_crashlog(void)
! 324: {
! 325: #define CRASHLOG_PREFIX "/var/tmp/quagga."
! 326: #define CRASHLOG_SUFFIX "crashlog"
! 327: if (zlog_default && zlog_default->ident)
! 328: {
! 329: /* Avoid strlen since it is not async-signal-safe. */
! 330: const char *p;
! 331: size_t ilen;
! 332:
! 333: for (p = zlog_default->ident, ilen = 0; *p; p++)
! 334: ilen++;
! 335: {
! 336: char buf[sizeof(CRASHLOG_PREFIX)+ilen+sizeof(CRASHLOG_SUFFIX)+3];
! 337: char *s = buf;
! 338: #define LOC s,buf+sizeof(buf)-s
! 339: s = str_append(LOC, CRASHLOG_PREFIX);
! 340: s = str_append(LOC, zlog_default->ident);
! 341: s = str_append(LOC, ".");
! 342: s = str_append(LOC, CRASHLOG_SUFFIX);
! 343: #undef LOC
! 344: *s = '\0';
! 345: return open(buf, O_WRONLY|O_CREAT|O_EXCL, LOGFILE_MASK);
! 346: }
! 347: }
! 348: return open(CRASHLOG_PREFIX CRASHLOG_SUFFIX, O_WRONLY|O_CREAT|O_EXCL,
! 349: LOGFILE_MASK);
! 350: #undef CRASHLOG_SUFFIX
! 351: #undef CRASHLOG_PREFIX
! 352: }
! 353:
! 354: /* Note: the goal here is to use only async-signal-safe functions. */
! 355: void
! 356: zlog_signal(int signo, const char *action
! 357: #ifdef SA_SIGINFO
! 358: , siginfo_t *siginfo, void *program_counter
! 359: #endif
! 360: )
! 361: {
! 362: time_t now;
! 363: char buf[sizeof("DEFAULT: Received signal S at T (si_addr 0xP, PC 0xP); aborting...")+100];
! 364: char *s = buf;
! 365: char *msgstart = buf;
! 366: #define LOC s,buf+sizeof(buf)-s
! 367:
! 368: time(&now);
! 369: if (zlog_default)
! 370: {
! 371: s = str_append(LOC,zlog_proto_names[zlog_default->protocol]);
! 372: *s++ = ':';
! 373: *s++ = ' ';
! 374: msgstart = s;
! 375: }
! 376: s = str_append(LOC,"Received signal ");
! 377: s = num_append(LOC,signo);
! 378: s = str_append(LOC," at ");
! 379: s = num_append(LOC,now);
! 380: #ifdef SA_SIGINFO
! 381: s = str_append(LOC," (si_addr 0x");
! 382: s = hex_append(LOC,(u_long)(siginfo->si_addr));
! 383: if (program_counter)
! 384: {
! 385: s = str_append(LOC,", PC 0x");
! 386: s = hex_append(LOC,(u_long)program_counter);
! 387: }
! 388: s = str_append(LOC,"); ");
! 389: #else /* SA_SIGINFO */
! 390: s = str_append(LOC,"; ");
! 391: #endif /* SA_SIGINFO */
! 392: s = str_append(LOC,action);
! 393: if (s < buf+sizeof(buf))
! 394: *s++ = '\n';
! 395:
! 396: /* N.B. implicit priority is most severe */
! 397: #define PRI LOG_CRIT
! 398:
! 399: #define DUMP(FD) write(FD, buf, s-buf);
! 400: /* If no file logging configured, try to write to fallback log file. */
! 401: if ((logfile_fd >= 0) || ((logfile_fd = open_crashlog()) >= 0))
! 402: DUMP(logfile_fd)
! 403: if (!zlog_default)
! 404: DUMP(STDERR_FILENO)
! 405: else
! 406: {
! 407: if (PRI <= zlog_default->maxlvl[ZLOG_DEST_STDOUT])
! 408: DUMP(STDOUT_FILENO)
! 409: /* Remove trailing '\n' for monitor and syslog */
! 410: *--s = '\0';
! 411: if (PRI <= zlog_default->maxlvl[ZLOG_DEST_MONITOR])
! 412: vty_log_fixed(buf,s-buf);
! 413: if (PRI <= zlog_default->maxlvl[ZLOG_DEST_SYSLOG])
! 414: syslog_sigsafe(PRI|zlog_default->facility,msgstart,s-msgstart);
! 415: }
! 416: #undef DUMP
! 417:
! 418: zlog_backtrace_sigsafe(PRI,
! 419: #ifdef SA_SIGINFO
! 420: program_counter
! 421: #else
! 422: NULL
! 423: #endif
! 424: );
! 425: #undef PRI
! 426: #undef LOC
! 427: }
! 428:
! 429: /* Log a backtrace using only async-signal-safe functions.
! 430: Needs to be enhanced to support syslog logging. */
! 431: void
! 432: zlog_backtrace_sigsafe(int priority, void *program_counter)
! 433: {
! 434: #ifdef HAVE_STACK_TRACE
! 435: static const char pclabel[] = "Program counter: ";
! 436: void *array[64];
! 437: int size;
! 438: char buf[100];
! 439: char *s, **bt = NULL;
! 440: #define LOC s,buf+sizeof(buf)-s
! 441:
! 442: #ifdef HAVE_GLIBC_BACKTRACE
! 443: if (((size = backtrace(array,sizeof(array)/sizeof(array[0]))) <= 0) ||
! 444: ((size_t)size > sizeof(array)/sizeof(array[0])))
! 445: return;
! 446:
! 447: #define DUMP(FD) { \
! 448: if (program_counter) \
! 449: { \
! 450: write(FD, pclabel, sizeof(pclabel)-1); \
! 451: backtrace_symbols_fd(&program_counter, 1, FD); \
! 452: } \
! 453: write(FD, buf, s-buf); \
! 454: backtrace_symbols_fd(array, size, FD); \
! 455: }
! 456: #elif defined(HAVE_PRINTSTACK)
! 457: #define DUMP(FD) { \
! 458: if (program_counter) \
! 459: write((FD), pclabel, sizeof(pclabel)-1); \
! 460: write((FD), buf, s-buf); \
! 461: printstack((FD)); \
! 462: }
! 463: #endif /* HAVE_GLIBC_BACKTRACE, HAVE_PRINTSTACK */
! 464:
! 465: s = buf;
! 466: s = str_append(LOC,"Backtrace for ");
! 467: s = num_append(LOC,size);
! 468: s = str_append(LOC," stack frames:\n");
! 469:
! 470: if ((logfile_fd >= 0) || ((logfile_fd = open_crashlog()) >= 0))
! 471: DUMP(logfile_fd)
! 472: if (!zlog_default)
! 473: DUMP(STDERR_FILENO)
! 474: else
! 475: {
! 476: if (priority <= zlog_default->maxlvl[ZLOG_DEST_STDOUT])
! 477: DUMP(STDOUT_FILENO)
! 478: /* Remove trailing '\n' for monitor and syslog */
! 479: *--s = '\0';
! 480: if (priority <= zlog_default->maxlvl[ZLOG_DEST_MONITOR])
! 481: vty_log_fixed(buf,s-buf);
! 482: if (priority <= zlog_default->maxlvl[ZLOG_DEST_SYSLOG])
! 483: syslog_sigsafe(priority|zlog_default->facility,buf,s-buf);
! 484: {
! 485: int i;
! 486: #ifdef HAVE_GLIBC_BACKTRACE
! 487: bt = backtrace_symbols(array, size);
! 488: #endif
! 489: /* Just print the function addresses. */
! 490: for (i = 0; i < size; i++)
! 491: {
! 492: s = buf;
! 493: if (bt)
! 494: s = str_append(LOC, bt[i]);
! 495: else {
! 496: s = str_append(LOC,"[bt ");
! 497: s = num_append(LOC,i);
! 498: s = str_append(LOC,"] 0x");
! 499: s = hex_append(LOC,(u_long)(array[i]));
! 500: }
! 501: *s = '\0';
! 502: if (priority <= zlog_default->maxlvl[ZLOG_DEST_MONITOR])
! 503: vty_log_fixed(buf,s-buf);
! 504: if (priority <= zlog_default->maxlvl[ZLOG_DEST_SYSLOG])
! 505: syslog_sigsafe(priority|zlog_default->facility,buf,s-buf);
! 506: }
! 507: if (bt)
! 508: free(bt);
! 509: }
! 510: }
! 511: #undef DUMP
! 512: #undef LOC
! 513: #endif /* HAVE_STRACK_TRACE */
! 514: }
! 515:
! 516: void
! 517: zlog_backtrace(int priority)
! 518: {
! 519: #ifndef HAVE_GLIBC_BACKTRACE
! 520: zlog(NULL, priority, "No backtrace available on this platform.");
! 521: #else
! 522: void *array[20];
! 523: int size, i;
! 524: char **strings;
! 525:
! 526: if (((size = backtrace(array,sizeof(array)/sizeof(array[0]))) <= 0) ||
! 527: ((size_t)size > sizeof(array)/sizeof(array[0])))
! 528: {
! 529: zlog_err("Cannot get backtrace, returned invalid # of frames %d "
! 530: "(valid range is between 1 and %lu)",
! 531: size, (unsigned long)(sizeof(array)/sizeof(array[0])));
! 532: return;
! 533: }
! 534: zlog(NULL, priority, "Backtrace for %d stack frames:", size);
! 535: if (!(strings = backtrace_symbols(array, size)))
! 536: {
! 537: zlog_err("Cannot get backtrace symbols (out of memory?)");
! 538: for (i = 0; i < size; i++)
! 539: zlog(NULL, priority, "[bt %d] %p",i,array[i]);
! 540: }
! 541: else
! 542: {
! 543: for (i = 0; i < size; i++)
! 544: zlog(NULL, priority, "[bt %d] %s",i,strings[i]);
! 545: free(strings);
! 546: }
! 547: #endif /* HAVE_GLIBC_BACKTRACE */
! 548: }
! 549:
! 550: void
! 551: zlog (struct zlog *zl, int priority, const char *format, ...)
! 552: {
! 553: va_list args;
! 554:
! 555: va_start(args, format);
! 556: vzlog (zl, priority, format, args);
! 557: va_end (args);
! 558: }
! 559:
! 560: #define ZLOG_FUNC(FUNCNAME,PRIORITY) \
! 561: void \
! 562: FUNCNAME(const char *format, ...) \
! 563: { \
! 564: va_list args; \
! 565: va_start(args, format); \
! 566: vzlog (NULL, PRIORITY, format, args); \
! 567: va_end(args); \
! 568: }
! 569:
! 570: ZLOG_FUNC(zlog_err, LOG_ERR)
! 571:
! 572: ZLOG_FUNC(zlog_warn, LOG_WARNING)
! 573:
! 574: ZLOG_FUNC(zlog_info, LOG_INFO)
! 575:
! 576: ZLOG_FUNC(zlog_notice, LOG_NOTICE)
! 577:
! 578: ZLOG_FUNC(zlog_debug, LOG_DEBUG)
! 579:
! 580: #undef ZLOG_FUNC
! 581:
! 582: #define PLOG_FUNC(FUNCNAME,PRIORITY) \
! 583: void \
! 584: FUNCNAME(struct zlog *zl, const char *format, ...) \
! 585: { \
! 586: va_list args; \
! 587: va_start(args, format); \
! 588: vzlog (zl, PRIORITY, format, args); \
! 589: va_end(args); \
! 590: }
! 591:
! 592: PLOG_FUNC(plog_err, LOG_ERR)
! 593:
! 594: PLOG_FUNC(plog_warn, LOG_WARNING)
! 595:
! 596: PLOG_FUNC(plog_info, LOG_INFO)
! 597:
! 598: PLOG_FUNC(plog_notice, LOG_NOTICE)
! 599:
! 600: PLOG_FUNC(plog_debug, LOG_DEBUG)
! 601:
! 602: #undef PLOG_FUNC
! 603:
! 604: void
! 605: _zlog_assert_failed (const char *assertion, const char *file,
! 606: unsigned int line, const char *function)
! 607: {
! 608: /* Force fallback file logging? */
! 609: if (zlog_default && !zlog_default->fp &&
! 610: ((logfile_fd = open_crashlog()) >= 0) &&
! 611: ((zlog_default->fp = fdopen(logfile_fd, "w")) != NULL))
! 612: zlog_default->maxlvl[ZLOG_DEST_FILE] = LOG_ERR;
! 613: zlog(NULL, LOG_CRIT, "Assertion `%s' failed in file %s, line %u, function %s",
! 614: assertion,file,line,(function ? function : "?"));
! 615: zlog_backtrace(LOG_CRIT);
! 616: abort();
! 617: }
! 618:
! 619:
! 620: /* Open log stream */
! 621: struct zlog *
! 622: openzlog (const char *progname, zlog_proto_t protocol,
! 623: int syslog_flags, int syslog_facility)
! 624: {
! 625: struct zlog *zl;
! 626: u_int i;
! 627:
! 628: zl = XCALLOC(MTYPE_ZLOG, sizeof (struct zlog));
! 629:
! 630: zl->ident = progname;
! 631: zl->protocol = protocol;
! 632: zl->facility = syslog_facility;
! 633: zl->syslog_options = syslog_flags;
! 634:
! 635: /* Set default logging levels. */
! 636: for (i = 0; i < sizeof(zl->maxlvl)/sizeof(zl->maxlvl[0]); i++)
! 637: zl->maxlvl[i] = ZLOG_DISABLED;
! 638: zl->maxlvl[ZLOG_DEST_MONITOR] = LOG_DEBUG;
! 639: zl->default_lvl = LOG_DEBUG;
! 640:
! 641: openlog (progname, syslog_flags, zl->facility);
! 642:
! 643: return zl;
! 644: }
! 645:
! 646: void
! 647: closezlog (struct zlog *zl)
! 648: {
! 649: closelog();
! 650:
! 651: if (zl->fp != NULL)
! 652: fclose (zl->fp);
! 653:
! 654: if (zl->filename != NULL)
! 655: free (zl->filename);
! 656:
! 657: XFREE (MTYPE_ZLOG, zl);
! 658: }
! 659:
! 660: /* Called from command.c. */
! 661: void
! 662: zlog_set_level (struct zlog *zl, zlog_dest_t dest, int log_level)
! 663: {
! 664: if (zl == NULL)
! 665: zl = zlog_default;
! 666:
! 667: zl->maxlvl[dest] = log_level;
! 668: }
! 669:
! 670: int
! 671: zlog_set_file (struct zlog *zl, const char *filename, int log_level)
! 672: {
! 673: FILE *fp;
! 674: mode_t oldumask;
! 675:
! 676: /* There is opend file. */
! 677: zlog_reset_file (zl);
! 678:
! 679: /* Set default zl. */
! 680: if (zl == NULL)
! 681: zl = zlog_default;
! 682:
! 683: /* Open file. */
! 684: oldumask = umask (0777 & ~LOGFILE_MASK);
! 685: fp = fopen (filename, "a");
! 686: umask(oldumask);
! 687: if (fp == NULL)
! 688: return 0;
! 689:
! 690: /* Set flags. */
! 691: zl->filename = strdup (filename);
! 692: zl->maxlvl[ZLOG_DEST_FILE] = log_level;
! 693: zl->fp = fp;
! 694: logfile_fd = fileno(fp);
! 695:
! 696: return 1;
! 697: }
! 698:
! 699: /* Reset opend file. */
! 700: int
! 701: zlog_reset_file (struct zlog *zl)
! 702: {
! 703: if (zl == NULL)
! 704: zl = zlog_default;
! 705:
! 706: if (zl->fp)
! 707: fclose (zl->fp);
! 708: zl->fp = NULL;
! 709: logfile_fd = -1;
! 710: zl->maxlvl[ZLOG_DEST_FILE] = ZLOG_DISABLED;
! 711:
! 712: if (zl->filename)
! 713: free (zl->filename);
! 714: zl->filename = NULL;
! 715:
! 716: return 1;
! 717: }
! 718:
! 719: /* Reopen log file. */
! 720: int
! 721: zlog_rotate (struct zlog *zl)
! 722: {
! 723: int level;
! 724:
! 725: if (zl == NULL)
! 726: zl = zlog_default;
! 727:
! 728: if (zl->fp)
! 729: fclose (zl->fp);
! 730: zl->fp = NULL;
! 731: logfile_fd = -1;
! 732: level = zl->maxlvl[ZLOG_DEST_FILE];
! 733: zl->maxlvl[ZLOG_DEST_FILE] = ZLOG_DISABLED;
! 734:
! 735: if (zl->filename)
! 736: {
! 737: mode_t oldumask;
! 738: int save_errno;
! 739:
! 740: oldumask = umask (0777 & ~LOGFILE_MASK);
! 741: zl->fp = fopen (zl->filename, "a");
! 742: save_errno = errno;
! 743: umask(oldumask);
! 744: if (zl->fp == NULL)
! 745: {
! 746: zlog_err("Log rotate failed: cannot open file %s for append: %s",
! 747: zl->filename, safe_strerror(save_errno));
! 748: return -1;
! 749: }
! 750: logfile_fd = fileno(zl->fp);
! 751: zl->maxlvl[ZLOG_DEST_FILE] = level;
! 752: }
! 753:
! 754: return 1;
! 755: }
! 756:
! 757: /* Message lookup function. */
! 758: const char *
! 759: lookup (const struct message *mes, int key)
! 760: {
! 761: const struct message *pnt;
! 762:
! 763: for (pnt = mes; pnt->key != 0; pnt++)
! 764: if (pnt->key == key)
! 765: return pnt->str;
! 766:
! 767: return "";
! 768: }
! 769:
! 770: /* Older/faster version of message lookup function, but requires caller to pass
! 771: * in the array size (instead of relying on a 0 key to terminate the search).
! 772: *
! 773: * The return value is the message string if found, or the 'none' pointer
! 774: * provided otherwise.
! 775: */
! 776: const char *
! 777: mes_lookup (const struct message *meslist, int max, int index,
! 778: const char *none, const char *mesname)
! 779: {
! 780: int pos = index - meslist[0].key;
! 781:
! 782: /* first check for best case: index is in range and matches the key
! 783: * value in that slot.
! 784: * NB: key numbering might be offset from 0. E.g. protocol constants
! 785: * often start at 1.
! 786: */
! 787: if ((pos >= 0) && (pos < max)
! 788: && (meslist[pos].key == index))
! 789: return meslist[pos].str;
! 790:
! 791: /* fall back to linear search */
! 792: {
! 793: int i;
! 794:
! 795: for (i = 0; i < max; i++, meslist++)
! 796: {
! 797: if (meslist->key == index)
! 798: {
! 799: const char *str = (meslist->str ? meslist->str : none);
! 800:
! 801: zlog_debug ("message index %d [%s] found in %s at position %d (max is %d)",
! 802: index, str, mesname, i, max);
! 803: return str;
! 804: }
! 805: }
! 806: }
! 807: zlog_err("message index %d not found in %s (max is %d)", index, mesname, max);
! 808: assert (none);
! 809: return none;
! 810: }
! 811:
! 812: /* Wrapper around strerror to handle case where it returns NULL. */
! 813: const char *
! 814: safe_strerror(int errnum)
! 815: {
! 816: const char *s = strerror(errnum);
! 817: return (s != NULL) ? s : "Unknown error";
! 818: }
! 819:
! 820: struct zebra_desc_table
! 821: {
! 822: unsigned int type;
! 823: const char *string;
! 824: char chr;
! 825: };
! 826:
! 827: #define DESC_ENTRY(T,S,C) [(T)] = { (T), (S), (C) }
! 828: static const struct zebra_desc_table route_types[] = {
! 829: DESC_ENTRY (ZEBRA_ROUTE_SYSTEM, "system", 'X' ),
! 830: DESC_ENTRY (ZEBRA_ROUTE_KERNEL, "kernel", 'K' ),
! 831: DESC_ENTRY (ZEBRA_ROUTE_CONNECT, "connected", 'C' ),
! 832: DESC_ENTRY (ZEBRA_ROUTE_STATIC, "static", 'S' ),
! 833: DESC_ENTRY (ZEBRA_ROUTE_RIP, "rip", 'R' ),
! 834: DESC_ENTRY (ZEBRA_ROUTE_RIPNG, "ripng", 'R' ),
! 835: DESC_ENTRY (ZEBRA_ROUTE_OSPF, "ospf", 'O' ),
! 836: DESC_ENTRY (ZEBRA_ROUTE_OSPF6, "ospf6", 'O' ),
! 837: DESC_ENTRY (ZEBRA_ROUTE_ISIS, "isis", 'I' ),
! 838: DESC_ENTRY (ZEBRA_ROUTE_BGP, "bgp", 'B' ),
! 839: DESC_ENTRY (ZEBRA_ROUTE_HSLS, "hsls", 'H' ),
! 840: };
! 841: #undef DESC_ENTRY
! 842:
! 843: #define DESC_ENTRY(T) [(T)] = { (T), (#T), '\0' }
! 844: static const struct zebra_desc_table command_types[] = {
! 845: DESC_ENTRY (ZEBRA_INTERFACE_ADD),
! 846: DESC_ENTRY (ZEBRA_INTERFACE_DELETE),
! 847: DESC_ENTRY (ZEBRA_INTERFACE_ADDRESS_ADD),
! 848: DESC_ENTRY (ZEBRA_INTERFACE_ADDRESS_DELETE),
! 849: DESC_ENTRY (ZEBRA_INTERFACE_UP),
! 850: DESC_ENTRY (ZEBRA_INTERFACE_DOWN),
! 851: DESC_ENTRY (ZEBRA_IPV4_ROUTE_ADD),
! 852: DESC_ENTRY (ZEBRA_IPV4_ROUTE_DELETE),
! 853: DESC_ENTRY (ZEBRA_IPV6_ROUTE_ADD),
! 854: DESC_ENTRY (ZEBRA_IPV6_ROUTE_DELETE),
! 855: DESC_ENTRY (ZEBRA_REDISTRIBUTE_ADD),
! 856: DESC_ENTRY (ZEBRA_REDISTRIBUTE_DELETE),
! 857: DESC_ENTRY (ZEBRA_REDISTRIBUTE_DEFAULT_ADD),
! 858: DESC_ENTRY (ZEBRA_REDISTRIBUTE_DEFAULT_DELETE),
! 859: DESC_ENTRY (ZEBRA_IPV4_NEXTHOP_LOOKUP),
! 860: DESC_ENTRY (ZEBRA_IPV6_NEXTHOP_LOOKUP),
! 861: DESC_ENTRY (ZEBRA_IPV4_IMPORT_LOOKUP),
! 862: DESC_ENTRY (ZEBRA_IPV6_IMPORT_LOOKUP),
! 863: DESC_ENTRY (ZEBRA_INTERFACE_RENAME),
! 864: DESC_ENTRY (ZEBRA_ROUTER_ID_ADD),
! 865: DESC_ENTRY (ZEBRA_ROUTER_ID_DELETE),
! 866: DESC_ENTRY (ZEBRA_ROUTER_ID_UPDATE),
! 867: };
! 868: #undef DESC_ENTRY
! 869:
! 870: static const struct zebra_desc_table unknown = { 0, "unknown", '?' };
! 871:
! 872: static const struct zebra_desc_table *
! 873: zroute_lookup(u_int zroute)
! 874: {
! 875: u_int i;
! 876:
! 877: if (zroute >= sizeof(route_types)/sizeof(route_types[0]))
! 878: {
! 879: zlog_err("unknown zebra route type: %u", zroute);
! 880: return &unknown;
! 881: }
! 882: if (zroute == route_types[zroute].type)
! 883: return &route_types[zroute];
! 884: for (i = 0; i < sizeof(route_types)/sizeof(route_types[0]); i++)
! 885: {
! 886: if (zroute == route_types[i].type)
! 887: {
! 888: zlog_warn("internal error: route type table out of order "
! 889: "while searching for %u, please notify developers", zroute);
! 890: return &route_types[i];
! 891: }
! 892: }
! 893: zlog_err("internal error: cannot find route type %u in table!", zroute);
! 894: return &unknown;
! 895: }
! 896:
! 897: const char *
! 898: zebra_route_string(u_int zroute)
! 899: {
! 900: return zroute_lookup(zroute)->string;
! 901: }
! 902:
! 903: char
! 904: zebra_route_char(u_int zroute)
! 905: {
! 906: return zroute_lookup(zroute)->chr;
! 907: }
! 908:
! 909: const char *
! 910: zserv_command_string (unsigned int command)
! 911: {
! 912: if (command >= sizeof(command_types)/sizeof(command_types[0]))
! 913: {
! 914: zlog_err ("unknown zserv command type: %u", command);
! 915: return unknown.string;
! 916: }
! 917: return command_types[command].string;
! 918: }
! 919:
! 920: #define RTSIZE (sizeof(route_types)/sizeof(route_types[0]))
! 921:
! 922: int
! 923: proto_name2num(const char *s)
! 924: {
! 925: unsigned i;
! 926:
! 927: for (i=0; i<RTSIZE; ++i)
! 928: if (strcasecmp(s, route_types[i].string) == 0)
! 929: return route_types[i].type;
! 930: return -1;
! 931: }
! 932: #undef RTSIZE
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 / quagga / lib