/[radius]/radius/radiusd/log.c
ViewVC logotype

Diff of /radius/radiusd/log.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.40 by gray, Fri Apr 18 05:27:10 2003 UTC revision 1.41 by gray, Tue Apr 29 13:57:59 2003 UTC
# Line 27  Line 27 
27  #include <errno.h>  #include <errno.h>
28  #include <syslog.h>  #include <syslog.h>
29  #include <radiusd.h>  #include <radiusd.h>
 #include <slist.h>  
30    
31  static int logging_category = L_CAT(L_MAIN);  static int logging_category = L_CAT(L_MAIN);
32  static Channel *chanlist;                  /* List of defined channels */  static LIST /* of Channel*/ *chanlist;     /* List of defined channels */
33    
34  static void log_to_channel(Channel *chan, int cat, int pri,  static void log_to_channel(Channel *chan, int cat, int pri,
35                             char *buf1, char *buf2, char *buf3);                             char *buf1, char *buf2, char *buf3);
# Line 87  vlog(int level, char *file, int line, ch Line 86  vlog(int level, char *file, int line, ch
86    
87          vasprintf(&buf2, fmt, ap);          vasprintf(&buf2, fmt, ap);
88                    
89          for (chan = chanlist; chan; chan = chan->next) {          for (chan = list_first(chanlist); chan; chan = list_next(chanlist)) {
90                  /* Skip channels whith incorrect priority */                  /* Skip channels whith incorrect priority */
91                  if (chan->pmask[cat] & L_MASK(pri))                  if (chan->pmask[cat] & L_MASK(pri))
92                          log_to_channel(chan, cat, pri, buf1, buf2, buf3);                          log_to_channel(chan, cat, pri, buf1, buf2, buf3);
# Line 256  channel_free(Channel *chan) Line 255  channel_free(Channel *chan)
255          efree(chan->name);          efree(chan->name);
256          if (chan->mode == LM_FILE)          if (chan->mode == LM_FILE)
257                  efree(chan->id.file);                  efree(chan->id.file);
258          mem_free(chan);          efree(chan);
 }  
   
 void  
 channel_free_list(Channel *chan)  
 {  
         Channel *next;  
   
         while (chan) {  
                 next = chan->next;  
                 channel_free(chan);  
                 chan = next;  
         }  
259  }  }
260    
261  Channel *  Channel *
262  log_mark()  log_mark()
263  {  {
264          return chanlist;          return list_first(chanlist);
265  }  }
266    
267  void  void
# Line 282  log_release(Channel *chan) Line 269  log_release(Channel *chan)
269  {  {
270          Channel *cp, *prev = NULL;          Channel *cp, *prev = NULL;
271          int emerg, alert, crit;          int emerg, alert, crit;
272            
273          for (cp = chanlist; cp; prev = cp, cp = cp->next)          cp = list_locate(chanlist, chan, NULL);
                 if (cp == chan)  
                         break;  
274    
275          while (cp) {          while (cp) {
276                  Channel *next = cp->next;                  if (!(cp->options & LO_PERSIST)) {
277                  if (cp->options & LO_PERSIST) {                          list_remove_current(chanlist);
                         if (prev)  
                                 prev->next = cp;  
                         prev = cp;  
                 } else {  
278                          channel_free(cp);                          channel_free(cp);
279                  }                  }
280                  cp = next;                  cp = list_next(chanlist);
281          }          }
         if (prev)  
                 prev->next = NULL;  
282    
283          /* Make sure we have at least a channel for categories below          /* Make sure we have at least a channel for categories below
284             L_CRIT */             L_CRIT */
285          emerg = L_EMERG;          emerg = L_EMERG;
286          alert = L_ALERT;          alert = L_ALERT;
287          crit  = L_CRIT;          crit  = L_CRIT;
288          for (cp = chanlist; cp; cp = cp->next) {          for (cp = list_first(chanlist); cp; cp = list_next(chanlist)) {
289                  int i;                  int i;
290                  for (i = 1; i < L_NCAT; i++) {                  for (i = 1; i < L_NCAT; i++) {
291                          if (emerg && (cp->pmask[i] & L_MASK(emerg)))                          if (emerg && (cp->pmask[i] & L_MASK(emerg)))
# Line 327  channel_lookup(char *name) Line 306  channel_lookup(char *name)
306  {  {
307          Channel *chan;          Channel *chan;
308    
309          for (chan = chanlist; chan; chan = chan->next) {          for (chan = list_first(chanlist); chan; chan = list_next(chanlist)) {
310                  if (strcmp(chan->name, name) == 0)                  if (strcmp(chan->name, name) == 0)
311                          break ;                          break ;
312          }          }
# Line 361  register_channel(Channel *chan) Line 340  register_channel(Channel *chan)
340          } else if (chan->mode == LM_SYSLOG) {          } else if (chan->mode == LM_SYSLOG) {
341          }          }
342    
343          channel = mem_alloc(sizeof(*channel));          channel = emalloc(sizeof(*channel));
344          channel->name = estrdup(chan->name);          channel->name = estrdup(chan->name);
345          channel->mode = chan->mode;          channel->mode = chan->mode;
346          if (chan->mode == LM_FILE)          if (chan->mode == LM_FILE)
# Line 369  register_channel(Channel *chan) Line 348  register_channel(Channel *chan)
348          else if (chan->mode == LM_SYSLOG)          else if (chan->mode == LM_SYSLOG)
349                  channel->id.prio = chan->id.prio;                  channel->id.prio = chan->id.prio;
350          channel->options = chan->options;          channel->options = chan->options;
351          channel->next = chanlist;  
352          chanlist = channel;          if (!chanlist)
353                    chanlist = list_create();
354            list_prepend(chanlist, channel);
355  }  }
356    
357  void  void
358  register_category(int cat, int pri, Chanlist *chanlist)  register_category0(int cat, int pri, Channel *chan)
359    {
360            if (cat == -1) {
361                    int i;
362                    for (i = 0; i < L_NCAT; i++)
363                            chan->pmask[i] |= pri;
364            } else
365                    chan->pmask[L_CAT(cat)] |= pri;
366    }
367    
368    void
369    register_category(int cat, int pri, LIST *clist)
370  {  {
371          Channel *chan;          Channel *chan;
372    
373          if (pri == -1)          if (pri == -1)
374                  pri = L_UPTO(L_DEBUG);                  pri = L_UPTO(L_DEBUG);
           
         for (; chanlist; chanlist = chanlist->next) {  
                 chan = chanlist->chan ? chanlist->chan  
                          : channel_lookup("default");  
   
                 if (cat == -1) {  
                         int i;  
                         for (i = 0; i < L_NCAT; i++)  
                                 chan->pmask[i] |= pri;  
                 } else  
                         chan->pmask[L_CAT(cat)] |= pri;  
         }  
 }  
375    
376  /* channel lists */          for (chan = list_first(clist); chan; chan = list_next(clist))
377  Chanlist *                  register_category0(cat, pri, chan);
 make_chanlist(Channel *chan)  
 {  
         Chanlist *cl = mem_alloc(sizeof(*cl));  
         cl->next = NULL;  
         cl->chan = chan;  
         return cl;  
 }  
           
 void  
 free_chanlist(Chanlist *cp)  
 {  
         free_slist((struct slist*)cp, NULL);  
378  }  }
379    
380  /* Auxiliary calls */  /* Auxiliary calls */
# Line 415  void Line 382  void
382  log_set_to_console()  log_set_to_console()
383  {  {
384          Channel chan;          Channel chan;
         Chanlist chanlist;  
385                    
386          chan.mode = LM_FILE;          chan.mode = LM_FILE;
387          chan.name = "stdout";          chan.name = "stdout";
# Line 423  log_set_to_console() Line 389  log_set_to_console()
389          chan.options = LO_CAT|LO_PRI|LO_PERSIST;          chan.options = LO_CAT|LO_PRI|LO_PERSIST;
390          register_channel(&chan);          register_channel(&chan);
391    
392          chanlist.next = NULL;          register_category0(-1, -1, channel_lookup("stdout"));
         chanlist.chan = channel_lookup("stdout");  
         register_category(-1, -1, &chanlist);  
393  }  }
394    
395  void  void
396  log_set_default(char *name, int cat, int pri)  log_set_default(char *name, int cat, int pri)
397  {  {
398          Channel chan;          Channel chan;
         Chanlist chanlist;  
399                    
400          chan.mode = LM_FILE;          chan.mode = LM_FILE;
401          chan.name = name;          chan.name = name;
# Line 441  log_set_default(char *name, int cat, int Line 404  log_set_default(char *name, int cat, int
404    
405          if (!channel_lookup(name))          if (!channel_lookup(name))
406                  register_channel(&chan);                  register_channel(&chan);
407            register_category0(cat, pri, channel_lookup(name));
         chanlist.next = NULL;  
         chanlist.chan = channel_lookup(name);  
         register_category(cat, pri, &chanlist);  
408  }  }
409    
410    
# Line 471  static struct category_def { Line 431  static struct category_def {
431          int init;          int init;
432          int cat;          int cat;
433          int pri;          int pri;
434          Chanlist *head, *tail;          LIST /* of Channel */ *clist;
435          int level;          int level;
436  } cat_def;  } cat_def;
437    
# Line 716  category_stmt_handler(int argc, cfg_valu Line 676  category_stmt_handler(int argc, cfg_valu
676                  return 0;                  return 0;
677          }          }
678          cat_def.init = 1;          cat_def.init = 1;
679          cat_def.head = cat_def.tail = NULL;          cat_def.clist = NULL;
680          return 0;          return 0;
681  }  }
682    
# Line 735  category_stmt_end(void *block_data, void Line 695  category_stmt_end(void *block_data, void
695                                         cfg_filename, cfg_line_num,                                         cfg_filename, cfg_line_num,
696                                  _("no levels applicable for this category"));                                  _("no levels applicable for this category"));
697                  }                  }
698                  register_category(cat_def.cat, cat_def.pri, cat_def.head);                  register_category(cat_def.cat, cat_def.pri, cat_def.clist);
699                  free_chanlist(cat_def.head);                  list_destroy(&cat_def.clist, NULL, NULL);
700          }          }
701          return 0;          return 0;
702  }  }
# Line 762  category_set_channel(int argc, cfg_value Line 722  category_set_channel(int argc, cfg_value
722                         _("%s:%d: channel `%s' not defined"),                         _("%s:%d: channel `%s' not defined"),
723                         cfg_filename, cfg_line_num, argv[1].v.string);                         cfg_filename, cfg_line_num, argv[1].v.string);
724          } else {          } else {
725                  Chanlist *chanlist = make_chanlist(channel);                  if (!cat_def.clist)
726                  if (cat_def.tail)                          cat_def.clist = list_create();
727                          cat_def.tail->next = chanlist;                  list_append(cat_def.clist, channel);
                 else  
                         cat_def.head = chanlist;  
                 cat_def.tail = chanlist;  
728          }          }
729                    
730          return 0;          return 0;

Legend:
Removed from v.1.40  
changed lines
  Added in v.1.41

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26