logger.c

   1 /*
   2  * Asterisk Logger
   3  *
   4  * Mark Spencer <markster@marko.net>
   5  *
   6  * Copyright(C)1999, Linux Support Services, Inc.
   7  *
   8  * Distributed under the terms of the GNU General Public License (GPL) Version 2
   9  *
  10  * Logging routines
  11  *
  12  */
  13
  14 #include <signal.h>
  15 #include <stdarg.h>
  16 #include <stdio.h>
  17 #include <unistd.h>
  18 #include <time.h>
  19 #include <asterisk/lock.h>
  20 #include <asterisk/logger.h>
  21 #include <asterisk/options.h>
  22 #include <asterisk/channel.h>
  23 #include <asterisk/config.h>
  24 #include <asterisk/term.h>
  25 #include <asterisk/cli.h>
  26 #include <string.h>
  27 #include <stdlib.h>
  28 #include <errno.h>
  29 #include <pthread.h>
  30 #include <sys/stat.h>
  31 #include <syslog.h>
  32 #include "asterisk.h"
  33 #include "astconf.h"
  34
  35 #define MAX_MSG_QUEUE 200
  36
  37 static ast_mutex_t msglist_lock = AST_MUTEX_INITIALIZER;
  38 static ast_mutex_t loglock = AST_MUTEX_INITIALIZER;
  39
  40 static struct msglist {
  41         char *msg;
  42         struct msglist *next;
  43 } *list = NULL, *last = NULL;
  44
  45 struct logfile {
  46         char fn[256];
  47         int logflags;
  48         FILE *f;
  49         int facility; /* syslog */
  50         struct logfile *next;
  51 };
  52
  53 static struct logfile *logfiles = NULL;
  54
  55 static int msgcnt = 0;
  56
  57 static FILE *eventlog = NULL;
  58
  59 static char *levels[] = {
  60         "DEBUG",
  61         "EVENT",
  62         "NOTICE",
  63         "WARNING",
  64         "ERROR"
  65 };
  66
  67 static int colors[] = {
  68         COLOR_BRGREEN,
  69         COLOR_BRBLUE,
  70         COLOR_YELLOW,
  71         COLOR_BRRED,
  72         COLOR_RED
  73 };
  74
  75
  76
  77 static int make_components(char *s, int lineno)
  78 {
  79         char *w;
  80         int res = 0;
  81         char *stringp=NULL;
  82         stringp=s;
  83         w = strsep(&stringp, ",");
  84         while(w) {
  85                 while(*w && (*w < 33))
  86                         w++;
  87                 if (!strcasecmp(w, "debug"))
  88                         res |= (1 << 0);
  89                 else if (!strcasecmp(w, "notice"))
  90                         res |= (1 << 2);
  91                 else if (!strcasecmp(w, "warning"))
  92                         res |= (1 << 3);
  93                 else if (!strcasecmp(w, "error"))
  94                         res |= (1 << 4);
  95                 else {
  96                         fprintf(stderr, "Logfile Warning: Unknown keyword '%s' at line %d of logger.conf\n", w, lineno);
  97                 }
  98                 w = strsep(&stringp, ",");
  99         }
 100         return res;
 101 }
 102
 103 static struct logfile *make_logfile(char *fn, char *components, int lineno)
 104 {
 105         struct logfile *f;
 106         char tmp[256];
 107         if (!strlen(fn))
 108                 return NULL;
 109         f = malloc(sizeof(struct logfile));
 110         if (f) {
 111                 memset(f, 0, sizeof(struct logfile));
 112                 strncpy(f->fn, fn, sizeof(f->fn) - 1);
 113                 if (!strcasecmp(fn, "ignore")) {
 114                         f->f = NULL;
 115                 } else if (!strcasecmp(fn, "console")) {
 116                         f->f = stdout;
 117                 } else if (!strcasecmp(fn, "syslog")) {
 118                   f->f = NULL;
 119                   f->facility = LOG_LOCAL0;
 120                 } else {
 121                         if (fn[0] == '/')
 122                                 strncpy(tmp, fn, sizeof(tmp) - 1);
 123                         else
 124                                 snprintf(tmp, sizeof(tmp), "%s/%s", (char *)ast_config_AST_LOG_DIR, fn);
 125                         f->f = fopen(tmp, "a");
 126                         if (!f->f) {
 127                                 /* Can't log here, since we're called with a lock */
 128                                 fprintf(stderr, "Logger Warning: Unable to open log file '%s': %s\n", tmp, strerror(errno));
 129                         }
 130                 }
 131                 f->logflags = make_components(components, lineno);
 132
 133         }
 134         return f;
 135 }
 136
 137 static void init_logger_chain(void)
 138 {
 139         struct logfile *f, *cur;
 140         struct ast_config *cfg;
 141         struct ast_variable *var;
 142
 143         ast_mutex_lock(&loglock);
 144
 145         /* Free anything that is here */
 146         f = logfiles;
 147         while(f) {
 148                 cur = f->next;
 149                 if (f->f && (f->f != stdout) && (f->f != stderr))
 150                         fclose(f->f);
 151                 free(f);
 152                 f = cur;
 153         }
 154
 155         logfiles = NULL;
 156
 157         ast_mutex_unlock(&loglock);
 158         cfg = ast_load("logger.conf");
 159         ast_mutex_lock(&loglock);
 160
 161         /* If no config file, we're fine */
 162         if (!cfg) {
 163                 ast_mutex_unlock(&loglock);
 164                 return;
 165         }
 166         var = ast_variable_browse(cfg, "logfiles");
 167         while(var) {
 168                 f = make_logfile(var->name, var->value, var->lineno);
 169                 if (f) {
 170                         f->next = logfiles;
 171                         logfiles = f;
 172                 }
 173                 var = var->next;
 174         }
 175         if (!logfiles) {
 176                 /* Gotta have at least one.  We'll make a NULL one */
 177                 logfiles = make_logfile("ignore", "", -1);
 178         }
 179         ast_destroy(cfg);
 180         ast_mutex_unlock(&loglock);
 181
 182
 183 }
 184
 185 int reload_logger(int rotate)
 186 {
 187         char old[AST_CONFIG_MAX_PATH];
 188         char new[AST_CONFIG_MAX_PATH];
 189         struct logfile *f;
 190         FILE *myf;
 191
 192         int x;
 193
 194         ast_mutex_lock(&loglock);
 195         if (eventlog)
 196           fclose(eventlog);
 197         else
 198           rotate = 0;
 199         eventlog = NULL;
 200
 201
 202
 203         mkdir((char *)ast_config_AST_LOG_DIR, 0755);
 204         snprintf(old, sizeof(old), "%s/%s", (char *)ast_config_AST_LOG_DIR, EVENTLOG);
 205
 206         if(rotate) {
 207                 for(x=0;;x++) {
 208                   snprintf(new, sizeof(new), "%s/%s.%d", (char *)ast_config_AST_LOG_DIR, EVENTLOG,x);
 209                   myf = fopen((char *)new, "r");
 210                   if(myf)
 211                     fclose(myf);
 212                   else
 213                     break;
 214                 }
 215
 216                   /* do it */
 217                 if (rename(old,new))
 218                         fprintf(stderr, "Unable to rename file '%s' to '%s'\n", old, new);
 219         }
 220
 221         eventlog = fopen(old, "a");
 222
 223         f = logfiles;
 224         while(f) {
 225           if (f->f && (f->f != stdout) && (f->f != stderr)) {
 226             fclose(f->f);
 227                 f->f = NULL;
 228             if(rotate) {
 229                     snprintf(old, sizeof(old), "%s/%s", (char *)ast_config_AST_LOG_DIR,f->fn);
 230
 231                     for(x=0;;x++) {
 232                       snprintf(new, sizeof(new), "%s/%s.%d", (char *)ast_config_AST_LOG_DIR,f->fn,x);
 233                       myf = fopen((char *)new, "r");
 234                       if(f)
 235                                         fclose(myf);
 236                       else
 237                                         break;
 238                     }
 239
 240                       /* do it */
 241                       if (rename(old,new))
 242                                 fprintf(stderr, "Unable to rename file '%s' to '%s'\n", old, new);
 243                     }
 244
 245
 246           }
 247
 248
 249           f = f->next;
 250         }
 251
 252
 253         ast_mutex_unlock(&loglock);
 254
 255         if (eventlog) {
 256                 init_logger_chain();
 257                 ast_log(LOG_EVENT, "Restarted Asterisk Event Logger\n");
 258                 if (option_verbose)
 259                         ast_verbose("Asterisk Event Logger restarted\n");
 260                 return 0;
 261         } else
 262                 ast_log(LOG_ERROR, "Unable to create event log: %s\n", strerror(errno));
 263         init_logger_chain();
 264         return -1;
 265 }
 266
 267 static int handle_logger_reload(int fd, int argc, char *argv[])
 268 {
 269         if(reload_logger(0))
 270         {
 271                 ast_cli(fd, "Failed to reloadthe logger\n");
 272                 return RESULT_FAILURE;
 273         }
 274         else
 275                 return RESULT_SUCCESS;
 276 }
 277
 278
 279
 280
 281
 282
 283
 284
 285 static int handle_logger_rotate(int fd, int argc, char *argv[])
 286 {
 287         if(reload_logger(1))
 288         {
 289                 ast_cli(fd, "Failed to reloadthe logger\n");
 290                 return RESULT_FAILURE;
 291         }
 292         else
 293                 return RESULT_SUCCESS;
 294 }
 295
 296 static struct verb {
 297         void (*verboser)(const char *string, int opos, int replacelast, int complete);
 298         struct verb *next;
 299 } *verboser = NULL;
 300
 301
 302 static char logger_reload_help[] =
 303 "Usage: logger reload\n"
 304 "       Reopens the log files.  Use after a rotating the log files\n";
 305
 306
 307 static char logger_rotate_help[] =
 308 "Usage: logger reload\n"
 309 "       Rotates and Reopens the log files.\n";
 310
 311
 312 static struct ast_cli_entry reload_logger_cli =
 313         { { "logger", "reload", NULL },
 314         handle_logger_reload, "Reopens the log files",
 315         logger_reload_help };
 316
 317
 318 static struct ast_cli_entry rotate_logger_cli =
 319         { { "logger", "rotate", NULL },
 320         handle_logger_rotate, "Reopens the log files",
 321         logger_rotate_help };
 322
 323
 324
 325 static int handle_SIGXFSZ(int sig) {
 326   reload_logger(1);
 327   ast_log(LOG_EVENT,"Rotated Logs Per SIGXFSZ\n");
 328   if (option_verbose)
 329     ast_verbose("Rotated Logs Per SIGXFSZ\n");
 330
 331   return 0;
 332 }
 333
 334 int init_logger(void)
 335 {
 336         char tmp[AST_CONFIG_MAX_PATH];
 337
 338
 339
 340         /* auto rotate if sig SIGXFSZ comes a-knockin */
 341         (void) signal(SIGXFSZ,(void *) handle_SIGXFSZ);
 342
 343         /* register the relaod logger cli command */
 344         ast_cli_register(&reload_logger_cli);
 345         ast_cli_register(&rotate_logger_cli);
 346
 347         mkdir((char *)ast_config_AST_LOG_DIR, 0755);
 348         snprintf(tmp, sizeof(tmp), "%s/%s", (char *)ast_config_AST_LOG_DIR, EVENTLOG);
 349         eventlog = fopen((char *)tmp, "a");
 350         if (eventlog) {
 351                 init_logger_chain();
 352                 ast_log(LOG_EVENT, "Started Asterisk Event Logger\n");
 353                 if (option_verbose)
 354                         ast_verbose("Asterisk Event Logger Started %s\n",(char *)tmp);
 355                 return 0;
 356         } else
 357                 ast_log(LOG_ERROR, "Unable to create event log: %s\n", strerror(errno));
 358         init_logger_chain();
 359         return -1;
 360 }
 361
 362
 363 extern void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...)
 364 {
 365         char date[256];
 366         char tmp[80];
 367         char tmp2[80];
 368         char tmp3[80];
 369         char tmp4[80];
 370         char linestr[80];
 371         time_t t;
 372         struct tm tm;
 373         struct logfile *f;
 374
 375         va_list ap;
 376         if (!option_verbose && !option_debug && (!level)) {
 377                 return;
 378         }
 379         ast_mutex_lock(&loglock);
 380         if (level == 1 /* Event */) {
 381                 time(&t);
 382                 localtime_r(&t,&tm);
 383                 if (&tm) {
 384                         /* Log events into the event log file, with a different format */
 385                         strftime(date, sizeof(date), "%b %e %T", &tm);
 386                         fprintf(eventlog, "%s asterisk[%d]: ", date, getpid());
 387                         va_start(ap, fmt);
 388                         vfprintf(eventlog, fmt, ap);
 389                         va_end(ap);
 390                         fflush(eventlog);
 391                 } else
 392                         /** Cannot use ast_log() from locked section of ast_log()!
 393                             ast_log(LOG_WARNING, "Unable to retrieve local time?\n"); **/
 394                         fprintf(stderr, "ast_log: Unable to retrieve local time for %ld?\n", (long)t);
 395         } else {
 396                 if (logfiles) {
 397                         f = logfiles;
 398                         while(f) {
 399                           if (f->logflags & (1 << level) && f->facility) {
 400                             time(&t);
 401                             localtime_r(&t,&tm);
 402                             strftime(date, sizeof(date), "%b %e %T", &tm);
 403
 404                             openlog("asterisk_pbx",LOG_PID,f->facility);
 405                             syslog(LOG_INFO|f->facility,"%s %s[%ld]: File %s, Line %d (%s): ",date,
 406                                    levels[level], (long)pthread_self(), file, line, function);
 407                             closelog();
 408
 409                           }
 410                           else if (f->logflags & (1 << level) && f->f) {
 411                                         if ((f->f != stdout) && (f->f != stderr)) {
 412                                                 time(&t);
 413                                                 localtime_r(&t,&tm);
 414                                                 strftime(date, sizeof(date), "%b %e %T", &tm);
 415                                                 fprintf(f->f, "%s %s[%ld]: File %s, Line %d (%s): ", date, levels[level], (long)pthread_self(), file, line, function);
 416                                         } else {
 417                                                 sprintf(linestr, "%d", line);
 418                                                 fprintf(f->f, "%s[%ld]: File %s, Line %s (%s): ",
 419                                                                                                                                 term_color(tmp, levels[level], colors[level], 0, sizeof(tmp)),
 420                                                                                                                                 (long)pthread_self(),
 421                                                                                                                                 term_color(tmp2, file, COLOR_BRWHITE, 0, sizeof(tmp2)),
 422                                                                                                                                 term_color(tmp3, linestr, COLOR_BRWHITE, 0, sizeof(tmp3)),
 423                                                                                                                                 term_color(tmp4, function, COLOR_BRWHITE, 0, sizeof(tmp4)));
 424                                         }
 425                                         va_start(ap, fmt);
 426                                         vfprintf(f->f, fmt, ap);
 427                                         va_end(ap);
 428                                         fflush(f->f);
 429                                 }
 430                                 f = f->next;
 431                         }
 432                 } else {
 433                         fprintf(stdout, "%s[%ld]: File %s, Line %d (%s): ", levels[level], (long)pthread_self(), file, line, function);
 434                         va_start(ap, fmt);
 435                         vfprintf(stdout, fmt, ap);
 436                         va_end(ap);
 437                         fflush(stdout);
 438                 }
 439         }
 440         ast_mutex_unlock(&loglock);
 441 }
 442
 443 extern void ast_verbose(const char *fmt, ...)
 444 {
 445         static char stuff[4096];
 446         static int pos = 0, opos;
 447         static int replacelast = 0, complete;
 448         struct msglist *m;
 449         struct verb *v;
 450         va_list ap;
 451         va_start(ap, fmt);
 452         ast_mutex_lock(&msglist_lock);
 453         vsnprintf(stuff + pos, sizeof(stuff) - pos, fmt, ap);
 454         opos = pos;
 455         pos = strlen(stuff);
 456         if (fmt[strlen(fmt)-1] == '\n')
 457                 complete = 1;
 458         else
 459                 complete=0;
 460         if (complete) {
 461                 if (msgcnt < MAX_MSG_QUEUE) {
 462                         /* Allocate new structure */
 463                         m = malloc(sizeof(struct msglist));
 464                         msgcnt++;
 465                 } else {
 466                         /* Recycle the oldest entry */
 467                         m = list;
 468                         list = list->next;
 469                         free(m->msg);
 470                 }
 471                 if (m) {
 472                         m->msg = strdup(stuff);
 473                         if (m->msg) {
 474                                 if (last)
 475                                         last->next = m;
 476                                 else
 477                                         list = m;
 478                                 m->next = NULL;
 479                                 last = m;
 480                         } else {
 481                                 msgcnt--;
 482                                 ast_log(LOG_ERROR, "Out of memory\n");
 483                                 free(m);
 484                         }
 485                 }
 486         }
 487         if (verboser) {
 488                 v = verboser;
 489                 while(v) {
 490                         v->verboser(stuff, opos, replacelast, complete);
 491                         v = v->next;
 492                 }
 493         } /* else
 494                 fprintf(stdout, stuff + opos); */
 495
 496         if (fmt[strlen(fmt)-1] != '\n')
 497                 replacelast = 1;
 498         else
 499                 replacelast = pos = 0;
 500         va_end(ap);
 501         ast_mutex_unlock(&msglist_lock);
 502 }
 503
 504 int ast_verbose_dmesg(void (*v)(const char *string, int opos, int replacelast, int complete))
 505 {
 506         struct msglist *m;
 507         m = list;
 508         ast_mutex_lock(&msglist_lock);
 509         while(m) {
 510                 /* Send all the existing entries that we have queued (i.e. they're likely to have missed) */
 511                 v(m->msg, 0, 0, 1);
 512                 m = m->next;
 513         }
 514         ast_mutex_unlock(&msglist_lock);
 515         return 0;
 516 }
 517
 518 int ast_register_verbose(void (*v)(const char *string, int opos, int replacelast, int complete))
 519 {
 520         struct msglist *m;
 521         struct verb *tmp;
 522         /* XXX Should be more flexible here, taking > 1 verboser XXX */
 523         if ((tmp = malloc(sizeof (struct verb)))) {
 524                 tmp->verboser = v;
 525                 ast_mutex_lock(&msglist_lock);
 526                 tmp->next = verboser;
 527                 verboser = tmp;
 528                 m = list;
 529                 while(m) {
 530                         /* Send all the existing entries that we have queued (i.e. they're likely to have missed) */
 531                         v(m->msg, 0, 0, 1);
 532                         m = m->next;
 533                 }
 534                 ast_mutex_unlock(&msglist_lock);
 535                 return 0;
 536         }
 537         return -1;
 538 }
 539
 540 int ast_unregister_verbose(void (*v)(const char *string, int opos, int replacelast, int complete))
 541 {
 542         int res = -1;
 543         struct verb *tmp, *tmpl=NULL;
 544         ast_mutex_lock(&msglist_lock);
 545         tmp = verboser;
 546         while(tmp) {
 547                 if (tmp->verboser == v) {
 548                         if (tmpl)
 549                                 tmpl->next = tmp->next;
 550                         else
 551                                 verboser = tmp->next;
 552                         free(tmp);
 553                         break;
 554                 }
 555                 tmpl = tmp;
 556                 tmp = tmp->next;
 557         }
 558         if (tmp)
 559                 res = 0;
 560         ast_mutex_unlock(&msglist_lock);
 561         return res;
 562 }