paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 1 | /* 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 | |
| 28 | struct zlog *zlog_default = NULL; |
| 29 | |
| 30 | const char *zlog_proto_names[] = |
| 31 | { |
| 32 | "NONE", |
| 33 | "DEFAULT", |
| 34 | "ZEBRA", |
| 35 | "RIP", |
| 36 | "BGP", |
| 37 | "OSPF", |
| 38 | "RIPNG", |
| 39 | "OSPF6", |
jardin | 9e867fe | 2003-12-23 08:56:18 +0000 | [diff] [blame] | 40 | "ISIS", |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 41 | "MASC", |
| 42 | NULL, |
| 43 | }; |
| 44 | |
| 45 | const 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. */ |
| 64 | static void |
| 65 | time_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. */ |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 84 | static void |
| 85 | vzlog (struct zlog *zl, int priority, const char *format, va_list args) |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 86 | { |
| 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"); |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 96 | vfprintf (stderr, format, args); |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 97 | 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) |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 110 | { |
| 111 | va_list ac; |
| 112 | va_copy(ac, args); |
| 113 | vsyslog (priority|zlog_default->facility, format, ac); |
| 114 | va_end(ac); |
| 115 | } |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 116 | |
| 117 | /* File output. */ |
| 118 | if (zl->flags & ZLOG_FILE) |
| 119 | { |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 120 | va_list ac; |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 121 | time_print (zl->fp); |
hasso | b04c699 | 2004-10-04 19:10:31 +0000 | [diff] [blame] | 122 | if (zl->record_priority) |
| 123 | fprintf (zl->fp, "%s: ", zlog_priority[priority]); |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 124 | fprintf (zl->fp, "%s: ", zlog_proto_names[zl->protocol]); |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 125 | va_copy(ac, args); |
| 126 | vfprintf (zl->fp, format, ac); |
| 127 | va_end(ac); |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 128 | fprintf (zl->fp, "\n"); |
| 129 | fflush (zl->fp); |
| 130 | } |
| 131 | |
| 132 | /* stdout output. */ |
| 133 | if (zl->flags & ZLOG_STDOUT) |
| 134 | { |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 135 | va_list ac; |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 136 | time_print (stdout); |
hasso | b04c699 | 2004-10-04 19:10:31 +0000 | [diff] [blame] | 137 | if (zl->record_priority) |
| 138 | fprintf (stdout, "%s: ", zlog_priority[priority]); |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 139 | fprintf (stdout, "%s: ", zlog_proto_names[zl->protocol]); |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 140 | va_copy(ac, args); |
| 141 | vfprintf (stdout, format, ac); |
| 142 | va_end(ac); |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 143 | fprintf (stdout, "\n"); |
| 144 | fflush (stdout); |
| 145 | } |
| 146 | |
| 147 | /* stderr output. */ |
| 148 | if (zl->flags & ZLOG_STDERR) |
| 149 | { |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 150 | va_list ac; |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 151 | time_print (stderr); |
hasso | b04c699 | 2004-10-04 19:10:31 +0000 | [diff] [blame] | 152 | if (zl->record_priority) |
| 153 | fprintf (stderr, "%s: ", zlog_priority[priority]); |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 154 | fprintf (stderr, "%s: ", zlog_proto_names[zl->protocol]); |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 155 | va_copy(ac, args); |
| 156 | vfprintf (stderr, format, ac); |
| 157 | va_end(ac); |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 158 | fprintf (stderr, "\n"); |
| 159 | fflush (stderr); |
| 160 | } |
| 161 | |
| 162 | /* Terminal monitor. */ |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 163 | vty_log (zlog_proto_names[zl->protocol], format, args); |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 164 | } |
| 165 | |
ajs | 59a06a9 | 2004-11-23 18:19:14 +0000 | [diff] [blame^] | 166 | static char * |
| 167 | str_append(char *dst, int len, const char *src) |
| 168 | { |
| 169 | while ((len-- > 0) && *src) |
| 170 | *dst++ = *src++; |
| 171 | return dst; |
| 172 | } |
| 173 | |
| 174 | static char * |
| 175 | num_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. */ |
| 190 | void |
| 191 | zlog_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 | |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 264 | void |
| 265 | zlog (struct zlog *zl, int priority, const char *format, ...) |
| 266 | { |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 267 | va_list args; |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 268 | |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 269 | va_start(args, format); |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 270 | vzlog (zl, priority, format, args); |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 271 | va_end (args); |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 272 | } |
| 273 | |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 274 | #define ZLOG_FUNC(FUNCNAME,PRIORITY) \ |
| 275 | void \ |
| 276 | FUNCNAME(const char *format, ...) \ |
| 277 | { \ |
| 278 | va_list args; \ |
| 279 | va_start(args, format); \ |
| 280 | vzlog (NULL, PRIORITY, format, args); \ |
| 281 | va_end(args); \ |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 282 | } |
| 283 | |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 284 | ZLOG_FUNC(zlog_err, LOG_ERR) |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 285 | |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 286 | ZLOG_FUNC(zlog_warn, LOG_WARNING) |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 287 | |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 288 | ZLOG_FUNC(zlog_info, LOG_INFO) |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 289 | |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 290 | ZLOG_FUNC(zlog_notice, LOG_NOTICE) |
| 291 | |
| 292 | ZLOG_FUNC(zlog_debug, LOG_DEBUG) |
| 293 | |
| 294 | #undef ZLOG_FUNC |
| 295 | |
| 296 | #define PLOG_FUNC(FUNCNAME,PRIORITY) \ |
| 297 | void \ |
| 298 | FUNCNAME(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); \ |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 304 | } |
| 305 | |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 306 | PLOG_FUNC(plog_err, LOG_ERR) |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 307 | |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 308 | PLOG_FUNC(plog_warn, LOG_WARNING) |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 309 | |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 310 | PLOG_FUNC(plog_info, LOG_INFO) |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 311 | |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 312 | PLOG_FUNC(plog_notice, LOG_NOTICE) |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 313 | |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 314 | PLOG_FUNC(plog_debug, LOG_DEBUG) |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 315 | |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 316 | #undef PLOG_FUNC |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 317 | |
| 318 | |
| 319 | /* Open log stream */ |
| 320 | struct zlog * |
| 321 | openzlog (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 | |
| 341 | void |
| 342 | closezlog (struct zlog *zl) |
| 343 | { |
| 344 | closelog(); |
| 345 | fclose (zl->fp); |
| 346 | |
| 347 | XFREE (MTYPE_ZLOG, zl); |
| 348 | } |
| 349 | |
| 350 | /* Called from command.c. */ |
| 351 | void |
| 352 | zlog_set_flag (struct zlog *zl, int flags) |
| 353 | { |
| 354 | if (zl == NULL) |
| 355 | zl = zlog_default; |
| 356 | |
| 357 | zl->flags |= flags; |
| 358 | } |
| 359 | |
| 360 | void |
| 361 | zlog_reset_flag (struct zlog *zl, int flags) |
| 362 | { |
| 363 | if (zl == NULL) |
| 364 | zl = zlog_default; |
| 365 | |
| 366 | zl->flags &= ~flags; |
| 367 | } |
| 368 | |
| 369 | int |
ajs | d246bd9 | 2004-11-23 17:35:08 +0000 | [diff] [blame] | 370 | zlog_set_file (struct zlog *zl, const char *filename) |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 371 | { |
| 372 | FILE *fp; |
gdt | aa593d5 | 2003-12-22 20:15:53 +0000 | [diff] [blame] | 373 | mode_t oldumask; |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 374 | |
| 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. */ |
gdt | aa593d5 | 2003-12-22 20:15:53 +0000 | [diff] [blame] | 383 | oldumask = umask (0777 & ~LOGFILE_MASK); |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 384 | fp = fopen (filename, "a"); |
| 385 | if (fp == NULL) |
gdt | aa593d5 | 2003-12-22 20:15:53 +0000 | [diff] [blame] | 386 | { |
| 387 | umask(oldumask); |
| 388 | return 0; |
| 389 | } |
| 390 | umask(oldumask); |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 391 | |
| 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. */ |
| 401 | int |
| 402 | zlog_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. */ |
| 421 | int |
| 422 | zlog_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 | { |
gdt | aa593d5 | 2003-12-22 20:15:53 +0000 | [diff] [blame] | 435 | mode_t oldumask; |
| 436 | |
| 437 | oldumask = umask (0777 & ~LOGFILE_MASK); |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 438 | fp = fopen (zl->filename, "a"); |
| 439 | if (fp == NULL) |
gdt | aa593d5 | 2003-12-22 20:15:53 +0000 | [diff] [blame] | 440 | { |
| 441 | umask(oldumask); |
| 442 | return -1; |
| 443 | } |
| 444 | umask(oldumask); |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 445 | zl->fp = fp; |
| 446 | } |
| 447 | |
| 448 | return 1; |
| 449 | } |
| 450 | |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 451 | /* Message lookup function. */ |
hasso | 8c328f1 | 2004-10-05 21:01:23 +0000 | [diff] [blame] | 452 | const char * |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 453 | lookup (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 |
hasso | b04c699 | 2004-10-04 19:10:31 +0000 | [diff] [blame] | 465 | used in bgpd and ospfd. FIXME Seems that it's not used any more. */ |
hasso | 8c328f1 | 2004-10-05 21:01:23 +0000 | [diff] [blame] | 466 | const char * |
paul | 718e374 | 2002-12-13 20:15:29 +0000 | [diff] [blame] | 467 | mes_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 | } |
ajs | ca35976 | 2004-11-19 23:40:16 +0000 | [diff] [blame] | 476 | |
| 477 | /* Wrapper around strerror to handle case where it returns NULL. */ |
| 478 | const char * |
| 479 | safe_strerror(int errnum) |
| 480 | { |
| 481 | const char *s = strerror(errnum); |
| 482 | return (s != NULL) ? s : "Unknown error"; |
| 483 | } |