lib/log.c

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