ulut/ul_logreg.c

   1 /*******************************************************************
   2   uLan Utilities Library - C library of basic reusable constructions
   3
   4   ul_logreg.c   - registration of logging domains
   5
   6   (C) Copyright 2006 by Pavel Pisa - Originator
   7
   8   The uLan utilities library can be used, copied and modified under
   9   next licenses
  10     - GPL - GNU General Public License
  11     - LGPL - GNU Lesser General Public License
  12     - MPL - Mozilla Public License
  13     - and other licenses added by project originators
  14   Code can be modified and re-distributed under any combination
  15   of the above listed licenses. If contributor does not agree with
  16   some of the licenses, he/she can delete appropriate line.
  17   Warning, if you delete all lines, you are not allowed to
  18   distribute source code and/or binaries utilizing code.
  19
  20   See files COPYING and README for details.
  21
  22  *******************************************************************/
  23
  24 #include <ctype.h>
  25 #include <string.h>
  26 #include <stdlib.h>
  27 #include <ul_logbase.h>
  28 #include <ul_logreg.h>
  29 #include <ul_gsacust.h>
  30
  31
  32 typedef struct ul_log_domains_t {
  33  #ifdef UL_LOG_DOMAINS_STATIC
  34   /*gsa_static_array_field_t domains;*/
  35   struct {
  36     ul_log_domain_t * const* items;
  37     int count;
  38   } domains;
  39  #else /*UL_LOG_DOMAINS_STATIC*/
  40   gsa_array_field_t domains;
  41  #endif /*UL_LOG_DOMAINS_STATIC*/
  42 } ul_log_domains_t;
  43
  44 typedef const char *ul_log_domains_key_t;
  45
  46 inline int
  47 ul_log_domains_cmp_fnc(const ul_log_domains_key_t *a, const ul_log_domains_key_t *b)
  48 {
  49   return strcmp(*a,*b);
  50 }
  51
  52 /* Custom array declarations */
  53 #ifdef UL_LOG_DOMAINS_STATIC
  54
  55 GSA_STATIC_CUST_DEC(ul_log_domains, ul_log_domains_t, ul_log_domain_t, ul_log_domains_key_t,
  56         domains, name, ul_log_domains_cmp_fnc)
  57
  58 GSA_STATIC_CUST_IMP(ul_log_domains, ul_log_domains_t, ul_log_domain_t, ul_log_domains_key_t,
  59         domains, name, ul_log_domains_cmp_fnc, 0)
  60
  61 #else /*UL_LOG_DOMAINS_STATIC*/
  62
  63 GSA_CUST_DEC(ul_log_domains, ul_log_domains_t, ul_log_domain_t, ul_log_domains_key_t,
  64         domains, name, ul_log_domains_cmp_fnc)
  65
  66 GSA_CUST_IMP(ul_log_domains, ul_log_domains_t, ul_log_domain_t, ul_log_domains_key_t,
  67         domains, name, ul_log_domains_cmp_fnc, 0)
  68
  69 #endif /*UL_LOG_DOMAINS_STATIC*/
  70
  71 ul_log_domains_t ul_log_domains;
  72
  73 /*This is not ideal*/
  74 extern int ul_log_cutoff_level;
  75
  76 int ul_log_domain_setlevel(const char *name, int setlevel)
  77 {
  78   int all_fl=0;
  79
  80   ul_log_domains_it_t it;
  81   ul_log_domain_t *domain=NULL;
  82
  83   if(setlevel<0)
  84     return -1;
  85
  86   if(setlevel>UL_LOGL_MAX)
  87     setlevel=UL_LOGL_MAX;
  88
  89   if(!name)
  90     all_fl=1;
  91   else
  92     all_fl=!strcmp(name,"all") || !strcmp(name,"ALL");
  93
  94   if(!all_fl){
  95     domain=ul_log_domains_find(&ul_log_domains,&name);
  96     if(!domain){
  97       return 1;
  98     }
  99     domain->level=setlevel;
 100   }else{
 101     ul_for_each_it(ul_log_domains, &ul_log_domains, it){
 102       domain=ul_log_domains_it2item(&it);
 103       domain->level=setlevel;
 104     }
 105   }
 106
 107   return 0;
 108 }
 109
 110 int ul_log_domain_getlevel(const char *name)
 111 {
 112   ul_log_domain_t *domain=NULL;
 113
 114   if(!name)
 115     return -1;
 116
 117   domain=ul_log_domains_find(&ul_log_domains,&name);
 118   if(!domain){
 119     return -1;
 120   }
 121
 122   return domain->level;
 123 }
 124
 125 #ifndef UL_MAX_DOMAIN_NAME
 126 #define UL_MAX_DOMAIN_NAME 20
 127 #endif /*UL_MAX_DOMAIN_NAME*/
 128
 129 int ul_log_domain_arg2levels(const char *arg)
 130 {
 131   const char *p=arg;
 132   const char *r;
 133   int l;
 134   char name[UL_MAX_DOMAIN_NAME+1];
 135
 136   if(!arg)
 137     return -1;
 138
 139   while(*p){
 140     if(isdigit(*p)){
 141       strcpy(name,"all");
 142     }else{
 143       r=p;
 144       while(isalnum(*p)) p++;
 145       l=p-r;
 146       if(l>UL_MAX_DOMAIN_NAME)
 147         l=UL_MAX_DOMAIN_NAME;
 148       memcpy(name,r,l);
 149       name[l]=0;
 150       if(*p&&(*p!='.')&&(*p!='='))
 151         return p-arg;
 152       p++;
 153     }
 154     r=p;
 155     l=strtol(r,(char**)&p,0);
 156     if(!p||(p==r)||(*p&&(*p!=':')&&(*p!=',')))
 157       return p-arg;
 158     if(ul_log_domain_setlevel(name, l)<0)
 159       return p-arg;
 160     if(*p)
 161       p++;
 162   }
 163
 164   return 0;
 165 }
 166
 167 int ul_logreg_domain(ul_log_domain_t *domain)
 168 {
 169   ul_log_check_default_output();
 170   if(!domain->level)
 171     domain->level=ul_log_cutoff_level;
 172   return ul_log_domains_insert(&ul_log_domains,domain);
 173 }
 174
 175 int ul_logreg_domains_static(ul_log_domain_t *const *domains, int count)
 176 {
 177   if(!ul_log_domains.domains.items && !ul_log_domains.domains.alloc_count){
 178     ul_log_domains.domains.items=(void**)domains;
 179     ul_log_domains.domains.count=count;
 180     ul_log_check_default_output();
 181     while(count-->0){
 182       if(!(*domains)->level)
 183          (*domains)->level=ul_log_cutoff_level;
 184       domains++;
 185     }
 186     return 0;
 187   }
 188   while(count-->0){
 189     if(ul_logreg_domain(*(domains++))<0)
 190       return -1;
 191   }
 192   return 0;
 193 }