src/nobug_env.c

   1 /*
   2  This file is part of the NoBug debugging library.
   3
   4  Copyright (C)
   5    2007, 2008,                          Christian Thaeter <ct@pipapo.org>
   6
   7  This program is free software; you can redistribute it and/or modify
   8  it under the terms of the GNU General Public License as published by
   9  the Free Software Foundation; either version 2 of the License, or
  10  (at your option) any later version.
  11
  12  This program is distributed in the hope that it will be useful,
  13  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  GNU General Public License for more details.
  16
  17  You should have received a copy of the GNU General Public License
  18  along with this program; if not, contact Christian Thaeter <ct@pipapo.org>.
  19 */
  20 #define NOBUG_LIBNOBUG_C
  21 #include "nobug.h"
  22
  23 #include <unistd.h>
  24
  25 /*
  26   Env variable parsing
  27 */
  28
  29 /*
  30   Syntax:
  31
  32   logdecl_list --> logdecl, any( ',' logdecl_list)
  33   logdecl --> flag, opt(limitdecl, any(targetdecl))
  34   flag --> "identifier of a flag"
  35   limitdecl --> ':', "LIMITNAME"
  36   targetdecl --> '@', "targetname", opt(targetopts)
  37   targetopts --> '(', "options for target", ')', opt(targetopts)
  38
  39   examples:
  40   NOBUG_LOG='flag,other'                        # set the limit of the 'default' target a default limit
  41   NOBUG_LOG='flag:DEBUG'                        # set the limit of the 'default' target to DEBUG
  42   NOBUG_LOG='flag:DEBUG@console@syslog'         # set console and syslog limits for flag to DEBUG
  43   NOBUG_LOG='flag:DEBUG,other:TRACE@ringbuffer'
  44
  45   TODO:
  46   (options) on targets are not yet implemented
  47
  48 */
  49
  50 const struct
  51 {
  52   const char * name;
  53   int value;
  54 } nobug_limits[] =
  55   {
  56     { ":EMERG", LOG_EMERG },
  57     { ":ALERT", LOG_ALERT },
  58     { ":CRIT", LOG_CRIT },
  59     { ":ERR", LOG_ERR },
  60     { ":ERROR", LOG_ERR },
  61     { ":WARNING", LOG_WARNING },
  62     { ":WARN", LOG_WARNING },
  63     { ":NOTICE", LOG_NOTICE },
  64     { ":INFO", LOG_INFO },
  65     { ":DEBUG", LOG_DEBUG },
  66     { ":TRACE", LOG_DEBUG },
  67   };
  68
  69 const char* nobug_targets[] =
  70   {"@ringbuffer", "@console", "@file", "@syslog", "@application"};
  71
  72
  73 static int
  74 nobug_env_parse_string_option (const char** env, const char* key, char* value)
  75 {
  76   char* end = strchr (*env, ')');
  77   if (!end)
  78     return -1;
  79
  80   if (!strncasecmp (key, *env+1, strlen (key)))
  81     {
  82       char* delim = strchr (*env, '=');
  83       if (delim)
  84         {
  85           if (delim > end || end-delim > 256)
  86             return -1;
  87           strncat (value, delim+1, end-delim-1);
  88         }
  89       *env = end + 1;
  90       return 1;
  91     }
  92   return 0;
  93 }
  94
  95 static int
  96 nobug_env_parse_size_option (const char** env, const char* key, size_t* value)
  97 {
  98   char* end = strchr (*env, ')');
  99   if (!end)
 100     return -1;
 101
 102   if (!strncasecmp (key, *env+1, strlen (key)))
 103     {
 104       char* delim = strchr (*env, '=');
 105       if (!delim || sscanf (delim+1, "%zi", value) != 1)
 106         return -1;
 107       *env = end + 1;
 108       return 1;
 109     }
 110   return 0;
 111 }
 112
 113 static int
 114 nobug_env_parse_flag_option (const char** env, const char* key, int* flag, int mask)
 115 {
 116
 117   char* end = strchr (*env, ')');
 118   if (!end)
 119     return -1;
 120
 121   if (!strncasecmp (key, *env+1, strlen (key)))
 122     {
 123       //char* delim = strchr (*env, '='); TODO =yes =no =true =false =1 =0
 124       /*|| !delim || delim > end*/
 125       *flag ^= mask;
 126       *env = end + 1;
 127       return 1;
 128     }
 129   return 0;
 130 }
 131
 132 static int
 133 nobug_env_parse_int_option (const char** env, const char* key, int* value)
 134 {
 135   char* end = strchr (*env, ')');
 136   char* delim = strchr (*env, '=');
 137   if (!end || !delim || delim > end)
 138     return -1;
 139
 140   if (!strncasecmp (key, *env+1, strlen (key)))
 141     {
 142       if (sscanf (delim+1, "%i", value) != 1)
 143         return -1;
 144       *env = end + 1;
 145       return 1;
 146     }
 147   return 0;
 148 }
 149
 150 static int
 151 nobug_env_parse_drop_option (const char** env)
 152 {
 153   char* end = strchr (*env, ')');
 154   if (!end)
 155     return -1;
 156   *env = end + 1;
 157   return 0;
 158 }
 159
 160 int
 161 nobug_env_parse_flag (const char* env, struct nobug_flag* flag, int default_target, int default_limit, const struct nobug_context context)
 162 {
 163   int ret = -1;
 164   if (!env || !flag->name)
 165     return ret;
 166   size_t flaglen = strlen (flag->name);
 167
 168   if (flag != &nobug_flag_nobug)
 169     nobug_log (&nobug_flag_nobug, LOG_NOTICE, "NOBUG", context, " INIT_FLAG: %s", flag->name);
 170
 171   do
 172     {
 173       if (!strncmp(env, flag->name, flaglen))
 174         {
 175           /* flagname matches */
 176           int limit;
 177           env += flaglen;
 178           if (*env == ':')
 179             for (limit = 0; limit<11; ++limit)
 180               {
 181                 size_t limitlen = strlen (nobug_limits[limit].name);
 182                 if (!strncmp(env, nobug_limits[limit].name, limitlen))
 183                   {
 184                     /* found :LIMIT */
 185                     int target;
 186                     env += limitlen;
 187                     if (*env == '@')
 188                       while (*env == '@')
 189                         {
 190                           for (target = 0; target<5; ++target)
 191                             {
 192                               size_t targetlen = strlen (nobug_targets[target]);
 193                               if (!strncmp(env, nobug_targets[target], targetlen))
 194                                 {
 195                                   /* @target found */
 196                                   env += targetlen;
 197                                   int given = 0;
 198                                   int s = 0;
 199
 200                                   int fd = -1;
 201                                   char name[256];
 202                                   *name = '\0';
 203                                   size_t size = 4096;
 204                                   int flags = 0;
 205
 206                                   switch (target)
 207                                     {
 208                                     case NOBUG_TARGET_RINGBUFFER:
 209                                       while (*env == '(' && given >= 0)
 210                                         {
 211                                           /* (file=name) */
 212                                           if ((s = nobug_env_parse_string_option (&env, "file", name)))
 213                                             {
 214                                               given |= s;
 215                                               continue;
 216                                             }
 217
 218                                           /* (size=N) */
 219                                           if ((s = nobug_env_parse_size_option (&env, "size", &size)))
 220                                             {
 221                                               given |= s;
 222                                               continue;
 223                                             }
 224
 225                                           /* (append) (temp) (keep) */
 226                                           if ((s = nobug_env_parse_flag_option (&env, "append",
 227                                                                                 &flags, NOBUG_RINGBUFFER_APPEND)))
 228                                             {
 229                                               given |= s;
 230                                               continue;
 231                                             }
 232                                           if ((s = nobug_env_parse_flag_option (&env, "temp",
 233                                                                                 &flags, NOBUG_RINGBUFFER_TEMP)))
 234                                             {
 235                                               given |= s;
 236                                               continue;
 237                                             }
 238                                           if ((s = nobug_env_parse_flag_option (&env, "keep",
 239                                                                                 &flags, NOBUG_RINGBUFFER_KEEP)))
 240                                             {
 241                                               given |= s;
 242                                               continue;
 243                                             }
 244                                           if (nobug_env_parse_drop_option (&env))
 245                                             return -1;
 246                                         }
 247                                       if (given < 0)
 248                                         return -1;
 249                                       if (given)
 250                                         {
 251                                           /* create new ringbuffer for flag */
 252                                           if (flag->ringbuffer_target != &nobug_default_ringbuffer)
 253                                             nobug_ringbuffer_delete (flag->ringbuffer_target);
 254                                           flag->ringbuffer_target = nobug_ringbuffer_new (size, name, flags);
 255                                         }
 256                                       break;
 257                                     case NOBUG_TARGET_CONSOLE:
 258                                       while (*env == '(' && given >= 0)
 259                                         {
 260                                           /* (fd=N) */
 261                                           if ((s = nobug_env_parse_int_option (&env, "fd", &fd)))
 262                                             {
 263                                               given |= s;
 264                                               continue;
 265                                             }
 266                                           if (nobug_env_parse_drop_option (&env))
 267                                             return -1;
 268                                         }
 269                                       if (given < 0)
 270                                         return -1;
 271                                       if (given)
 272                                         {
 273                                           // open fd for console
 274                                           if (!write (fd, NULL, 0) && flag->console_target == stderr)
 275                                             flag->console_target = fdopen (fd, "w");
 276                                         }
 277                                       break;
 278                                     case NOBUG_TARGET_FILE:
 279                                       while (*env == '(' && given >= 0)
 280                                         {
 281                                           /* (name=name) */
 282                                           if ((s = nobug_env_parse_string_option (&env, "name", name)))
 283                                             {
 284                                               given |= s;
 285                                               continue;
 286                                             }
 287
 288                                           /* (append) */
 289                                           if ((s = nobug_env_parse_flag_option (&env, "append",
 290                                                                                 &flags, NOBUG_RINGBUFFER_APPEND)))
 291                                             {
 292                                               given |= s;
 293                                               continue;
 294                                             }
 295                                           if (nobug_env_parse_drop_option (&env))
 296                                             return -1;
 297                                         }
 298                                       if (given < 0)
 299                                         return -1;
 300                                       if (given)
 301                                         {
 302                                           FILE* new = fopen (name, flags?"a":"w");
 303                                           if (new)
 304                                             {
 305                                               if (flag->file_target)
 306                                                 fclose (flag->file_target);
 307                                               flag->file_target = new;
 308                                             }
 309                                         }
 310                                       break;
 311                                     case NOBUG_TARGET_SYSLOG:
 312                                       while (*env == '(' && given >= 0)
 313                                         {
 314                                           /* (facility=name) unimplemented */
 315                                           //given |= nobug_env_parse_string_option (&env, "facility", .. );
 316
 317                                           /* (ident=string) */
 318                                           if ((s = nobug_env_parse_string_option (&env, "ident", name)))
 319                                             {
 320                                               given |= s;
 321                                               continue;
 322                                             }
 323
 324                                           /* (cons) (pid) */
 325                                           if ((s = nobug_env_parse_flag_option (&env, "cons",
 326                                                                                 &flags, LOG_CONS)))
 327                                             {
 328                                               given |= s;
 329                                               continue;
 330                                             }
 331                                           if ((s = nobug_env_parse_flag_option (&env, "pid",
 332                                                                                 &flags, LOG_PID)))
 333                                             {
 334                                               given |= s;
 335                                               continue;
 336                                             }
 337                                           if ((s = nobug_env_parse_flag_option (&env, "perror",
 338                                                                                 &flags, LOG_PERROR)))
 339                                             {
 340                                               given |= s;
 341                                               continue;
 342                                             }
 343                                           if (nobug_env_parse_drop_option (&env))
 344                                             return -1;
 345                                         }
 346                                       if (given < 0)
 347                                         return -1;
 348                                       if (given)
 349                                         {
 350                                           closelog ();
 351                                           openlog (*name?strdup (name): NULL, flags, LOG_USER);
 352                                         }
 353                                       break;
 354                                     case NOBUG_TARGET_APPLICATION:
 355                                       // TODO
 356                                       break;
 357                                     }
 358                                   ret = flag->limits[target] = nobug_limits[limit].value;
 359                                 }
 360                             }
 361                         }
 362                     else
 363                       {
 364                         /* flag:LIMIT with no @target */
 365                         ret = flag->limits[default_target] = nobug_limits[limit].value;
 366                       }
 367                   }
 368               }
 369           else
 370             {
 371               /* flag with no :LIMIT */
 372               ret = flag->limits[default_target] = default_limit;
 373             }
 374         }
 375       env = strchr(env, ',');
 376       if (env)
 377         ++env;
 378     }
 379   while (env);
 380   return ret;
 381 }
 382
 383
 384 int
 385 nobug_env_init_flag (struct nobug_flag* flag, int default_target, int default_limit, const struct nobug_context context)
 386 {
 387   int i;
 388   nobug_init(context);
 389
 390   if (flag->initialized)
 391     return 1;
 392   flag->initialized = 1;
 393
 394   /* set some defaults */
 395   flag->ringbuffer_target = &nobug_default_ringbuffer;
 396   flag->console_target = stderr;
 397   flag->file_target = nobug_default_file;
 398
 399   if (flag->parent)
 400     {
 401       nobug_env_init_flag (flag->parent, default_target, default_limit, context);
 402
 403       for (i = NOBUG_TARGET_CONSOLE; i <= NOBUG_TARGET_APPLICATION; ++i)
 404         {
 405           flag->limits[i] = flag->parent->limits[i];
 406         }
 407       flag->ringbuffer_target = flag->parent->ringbuffer_target;
 408       flag->console_target = flag->parent->console_target;
 409       flag->file_target = flag->parent->file_target;
 410     }
 411
 412   /* parse $NOBUG_LOG */
 413   int ret = nobug_env_parse_flag (getenv("NOBUG_LOG"), flag, default_target, default_limit, context);
 414
 415   /* ensure that the ringbuffer is the most verbose */
 416   int max;
 417
 418   for (max = i = NOBUG_TARGET_CONSOLE; i <= NOBUG_TARGET_APPLICATION; ++i)
 419     {
 420       max = max > flag->limits[i] ? max : flag->limits[i];
 421     }
 422
 423   flag->limits[NOBUG_TARGET_RINGBUFFER] = max > flag->limits[NOBUG_TARGET_RINGBUFFER]
 424     ? max : flag->limits[NOBUG_TARGET_RINGBUFFER];
 425
 426   return ret;
 427 }