lib/silcutil/silcconfig.c

   1 /*
   2
   3   silcconfig.c
   4
   5   Author: Johnny Mnemonic <johnny@themnemonic.org>
   6
   7   Copyright (C) 1997 - 2002 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; either version 2 of the License, or
  12   (at your option) any later version.
  13
  14   This program is distributed in the hope that it will be useful,
  15   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17   GNU General Public License for more details.
  18
  19 */
  20 /* $Id$ */
  21
  22 #include "silcincludes.h"
  23
  24 /* limit debug logging verbosity */
  25 #if 0
  26 #define SILC_CONFIG_DEBUG(fmt) SILC_LOG_DEBUG(fmt)
  27 #else
  28 #define SILC_CONFIG_DEBUG(fmt)
  29 #endif
  30
  31 /* this is the option struct and currently it is only used internally to
  32  * the module and other structs. */
  33 typedef struct SilcConfigOptionStruct {
  34   char *name;                   /* *lowercase* name of the option */
  35   SilcConfigType type;          /* important: the type of the returned value */
  36   SilcConfigCallback cb;        /* the value handler */
  37   const SilcConfigTable *subtable; /* used if type is SILC_CONFIG_ARG_BLOCK */
  38   void *context;                /* context passed to the callback function */
  39   struct SilcConfigOptionStruct *next;
  40 } SilcConfigOption;
  41
  42 /* unique for each config file (and included ones) */
  43 struct SilcConfigFileObject {
  44   char *filename; /* the original filename opened */
  45   int level;    /* parsing level, how many nested silc_config_main we have */
  46   char *base;   /* this is a fixed pointer to the base location */
  47   char *p;      /* the Parser poitner */
  48   SilcUInt32 len;       /* fixed length of the whole file */
  49   SilcUInt32 line;      /* current parsing line, strictly linked to p */
  50   bool included; /* wether this file is main or included */
  51 };
  52
  53 /* We need the entity to base our block-style parsing on */
  54 struct SilcConfigEntityObject {
  55   SilcConfigOption *opts;       /* known options list */
  56   SilcConfigFile *file;         /* parsing file object */
  57 };
  58
  59 /* access error descriptions only with silc_config_strerror() */
  60 static char *errorstrs[] = {
  61   "-OK",                                        /* SILC_CONFIG_OK */
  62   "-SILENT",                                    /* SILC_CONFIG_ESILENT */
  63   "-PRINTLINE",                                 /* SILC_CONFIG_EPRINTLINE */
  64   "Invalid syntax",                             /* SILC_CONFIG_EGENERIC */
  65   "Internal error! Please report this bug",     /* SILC_CONFIG_EINTERNAL */
  66   "Can't open specified file",                  /* SILC_CONFIG_ECANTOPEN */
  67   "Expected open-brace '{'",                    /* SILC_CONFIG_EOPENBRACE */
  68   "Missing close-brace '}'",                    /* SILC_CONFIG_ECLOSEBRACE */
  69   "Invalid data type",                          /* SILC_CONFIG_ETYPE */
  70   "Unknown option",                             /* SILC_CONFIG_EBADOPTION */
  71   "Invalid text",                               /* SILC_CONFIG_EINVALIDTEXT */
  72   "Double option specification",                /* SILC_CONFIG_EDOUBLE */
  73   "Expected data but not found",                /* SILC_CONFIG_EEXPECTED */
  74   "Expected '='",                               /* SILC_CONFIG_EEXPECTEDEQUAL */
  75   "Unexpected data",                            /* SILC_CONFIG_EUNEXPECTED */
  76   "Missing mandatory fields",                   /* SILC_CONFIG_EMISSFIELDS */
  77   "Missing ';'",                                /* SILC_CONFIG_EMISSCOLON */
  78 };
  79
  80 /* return string describing SilcConfig's error code */
  81 char *silc_config_strerror(int errnum)
  82 {
  83   if ((errnum < 0) || (errnum >= sizeof(errorstrs)/sizeof(*errorstrs)) ||
  84     (errorstrs[errnum] == NULL)) {
  85     char *defret = "-INVALIDERROR";
  86     return defret;
  87   }
  88   return errorstrs[errnum];
  89 }
  90
  91 /* Begin of internal SilcConfig's text util functions */
  92
  93 /* Points the first non-space character */
  94 static void my_trim_spaces(SilcConfigFile *file)
  95 {
  96   register char *r = file->p;
  97   while (isspace(*r))
  98     if (*r++ == '\n') file->line++;
  99   file->p = r;
 100 }
 101 /* Skips the current line until newline (lf or cr) */
 102 static void my_skip_line(SilcConfigFile *file)
 103 {
 104   register char *r = file->p;
 105   while (*r && (*r != '\n') && (*r != '\r')) r++;
 106   file->p = (*r ? r + 1 : r);
 107   file->line++;
 108 }
 109 /* Obtains a text token from the current position until first separator.
 110  * a separator is any non alphanumeric character nor "_" or "-" */
 111 static char *my_next_token(SilcConfigFile *file, char *to)
 112 {
 113   register char *o;
 114   my_trim_spaces(file);
 115   o = file->p;
 116   while (isalnum(*o) || (*o == '_') || (*o == '-'))
 117     *to++ = *o++;
 118   *to = '\0';
 119   file->p = o;
 120   return to;
 121 }
 122 /* Obtains a string from the current position. The only difference from
 123  * next_token() is that quoted-strings are also accepted */
 124 static char *my_get_string(SilcConfigFile *file, char *to)
 125 {
 126   char *o;
 127   my_trim_spaces(file);
 128   o = file->p;
 129   if (*o == '"') {
 130     char *quot = strchr(++o, '"');
 131     int len = quot - o;
 132     if (!quot) { /* XXX FIXME: gotta do something here */
 133       printf("Bullshit, missing matching \"");
 134       exit(1);
 135     }
 136     if (len <= 0)
 137       *to = '\0';
 138     else {
 139       strncpy(to, o, len);
 140       to[len] = '\0';
 141     }
 142     /* update stream pointer */
 143     file->p = quot + 1;
 144     return to;
 145   }
 146   /* we don't need quote parsing, fall-back to token extractor */
 147   my_next_token(file, to);
 148   return to;
 149 };
 150 /* Skips all comment lines and spaces lines until first useful character */
 151 static void my_skip_comments(SilcConfigFile *file)
 152 {
 153   while (1) {
 154     my_trim_spaces(file);
 155     if (*file->p != '#') return;
 156     my_skip_line(file);
 157   }
 158 }
 159
 160 /* End of internal text functions
 161  * Next section contains SilcConfig internal config utils */
 162
 163 /* find an option in the list by name and returns its pointer */
 164 static SilcConfigOption *silc_config_find_option(SilcConfigEntity ent,
 165         const char *name)
 166 {
 167   SilcConfigOption *tmp;
 168   for (tmp = ent->opts; tmp; tmp = tmp->next) {
 169     if (!strcasecmp(tmp->name, name))
 170       return tmp;
 171   }
 172   return NULL;
 173 }
 174 /* ... */
 175 static void *silc_config_marshall(SilcConfigType type, const char *val)
 176 {
 177   void *pt;
 178   int val_int;
 179   bool val_bool;
 180   char *val_tmp;
 181   SilcUInt32 val_size;
 182
 183   switch (type) {
 184     case SILC_CONFIG_ARG_TOGGLE:
 185       if (!strcasecmp(val, "yes") || !strcasecmp(val, "true") ||
 186                 !strcasecmp(val, "on") || !strcasecmp(val, "1")) {
 187         val_bool = TRUE;
 188       }
 189       else if (!strcasecmp(val, "no") || !strcasecmp(val, "false") ||
 190                 !strcasecmp(val, "off") || !strcasecmp(val, "0")) {
 191         val_bool = FALSE;
 192       }
 193       else
 194         return NULL;
 195       pt = silc_calloc(1, sizeof(val_bool));
 196       *(bool *)pt = (bool) val_bool;
 197       return pt;
 198     case SILC_CONFIG_ARG_INT:
 199       val_int = (int) strtol(val, &val_tmp, 0);
 200       if (*val_tmp) /* error converting string */
 201         return NULL;
 202       pt = silc_calloc(1, sizeof(val_int));
 203       *(int *)pt = val_int;
 204       return pt;
 205     case SILC_CONFIG_ARG_SIZE:
 206       val_size = (SilcUInt32) strtol(val, &val_tmp, 0);
 207       if (val == val_tmp)
 208         return NULL; /* really wrong, there must be at least one digit */
 209       /* Search for a designator */
 210       switch (tolower(val_tmp[0])) {
 211         case '\0': /* None */
 212           break;
 213         case 'k': /* Kilobytes */
 214           val_size *= (SilcUInt32) 1024;
 215           break;
 216         case 'm': /* Megabytes */
 217           val_size *= (SilcUInt32) (1024 * 1024);
 218           break;
 219         case 'g':
 220           val_size *= (SilcUInt32) (1024 * 1024 * 1024);
 221           break;
 222         default:
 223           return NULL;
 224       }
 225       /* the string must die here */
 226       if (val_tmp[1])
 227         return NULL;
 228       pt = silc_calloc(1, sizeof(val_size));
 229       *(SilcUInt32 *)pt = val_size;
 230       return pt;
 231     case SILC_CONFIG_ARG_STR: /* the only difference between STR and STRE is */
 232       if (!val[0])            /* that STR cannot be empty, while STRE can.  */
 233         return NULL;
 234     case SILC_CONFIG_ARG_STRE:
 235       pt = (void *) strdup(val);
 236       return pt;
 237     /* following types are not supposed to have a return value */
 238     case SILC_CONFIG_ARG_BLOCK:
 239     case SILC_CONFIG_ARG_NONE:
 240       return NULL;
 241     default:
 242       return NULL;
 243   }
 244
 245   return NULL;
 246 }
 247
 248 /* End of internal functions */
 249
 250
 251 /* Tries to open the config file and returns a valid SilcConfigFile object
 252  * or NULL if failed */
 253
 254 SilcConfigFile *silc_config_open(const char *configfile)
 255 {
 256   char *buffer;
 257   SilcUInt32 filelen;
 258   SilcConfigFile *ret;
 259
 260   if (!(buffer = silc_file_readfile(configfile, &filelen)))
 261     return NULL;
 262
 263   ret = silc_calloc(1, sizeof(*ret));
 264   ret->filename = strdup(configfile);
 265   ret->base = ret->p = buffer;
 266   ret->len = filelen;
 267   ret->line = 1; /* line count, start from first line */
 268   return ret;
 269 }
 270
 271 /* Frees a file object */
 272
 273 void silc_config_close(SilcConfigFile *file)
 274 {
 275   if (file) {
 276     silc_free(file->filename);
 277     memset(file->base, 'F', file->len);
 278     silc_free(file->base);
 279     memset(file, 'F', sizeof(*file));
 280     silc_free(file);
 281   }
 282 }
 283
 284 /* initializes a SilcConfigEntity pointer allocation */
 285
 286 SilcConfigEntity silc_config_init(SilcConfigFile *file)
 287 {
 288   SilcConfigEntity ret;
 289
 290   if (!file)
 291     return NULL;
 292
 293   SILC_CONFIG_DEBUG(("Allocating new config entity"));
 294   ret = silc_calloc(1, sizeof(*ret));
 295   ret->file = file;
 296   return ret;
 297 };
 298
 299 /* Returns the original filename of the object file */
 300
 301 char *silc_config_get_filename(SilcConfigFile *file)
 302 {
 303   if (file)
 304     return file->filename;
 305   return NULL;
 306 }
 307
 308 /* Returns the current line that file parsing arrived at */
 309
 310 SilcUInt32 silc_config_get_line(SilcConfigFile *file)
 311 {
 312   if (file)
 313     return file->line;
 314   return 0;
 315 }
 316
 317 /* Returns a pointer to the beginning of the requested line.  If the line
 318  * was not found, NULL is returned */
 319
 320 char *silc_config_read_line(SilcConfigFile *file, SilcUInt32 line)
 321 {
 322   register char *p;
 323   int len;
 324   char *ret, *endbuf;
 325
 326   if (!file || (line <= 0))
 327     return NULL;
 328   for (p = file->base; *p && (*p != EOF); p++) {
 329     if (line <= 1)
 330       goto found;
 331     if (*p == '\n')
 332       line--;
 333   }
 334   return NULL;
 335
 336  found:
 337   if ((endbuf = strchr(p, '\n'))) {
 338     len = endbuf - p;
 339     ret = silc_memdup(p, len);
 340   } else {
 341     ret = silc_memdup(p, strlen(p));
 342   }
 343   return ret;
 344 }
 345
 346 /* Convenience function to read the current parsed line */
 347
 348 char *silc_config_read_current_line(SilcConfigFile *file)
 349 {
 350   return silc_config_read_line(file, file->line);
 351 }
 352
 353 /* (Private) destroy a SilcConfigEntity */
 354
 355 static void silc_config_destroy(SilcConfigEntity ent, bool destroy_opts)
 356 {
 357   SilcConfigOption *oldopt, *nextopt;
 358   SILC_CONFIG_DEBUG(("Freeing config entity [ent=0x%x] [opts=0x%x]",
 359                         (SilcUInt32) ent, (SilcUInt32) ent->opts));
 360
 361   /* if she wants to preserve options just free the object struct */
 362   if (!destroy_opts)
 363     goto skip_sect;
 364
 365   for (oldopt = ent->opts; oldopt; oldopt = nextopt) {
 366     nextopt = oldopt->next;
 367     memset(oldopt->name, 'F', strlen(oldopt->name) + 1);
 368     silc_free(oldopt->name);
 369     memset(oldopt, 'F', sizeof(*oldopt));
 370     silc_free(oldopt);
 371   }
 372
 373  skip_sect:
 374   memset(ent, 'F', sizeof(*ent));
 375   silc_free(ent);
 376 }
 377
 378 /* Registers a new option in the specified entity.
 379  * Returns TRUE on success, FALSE if already registered. */
 380
 381 bool silc_config_register(SilcConfigEntity ent, const char *name,
 382                           SilcConfigType type, SilcConfigCallback cb,
 383                           const SilcConfigTable *subtable, void *context)
 384 {
 385   SilcConfigOption *newopt;
 386   SILC_CONFIG_DEBUG(("Register new option=\"%s\" type=%u cb=0x%08x context=0x%08x",
 387                 name, type, (SilcUInt32) cb, (SilcUInt32) context));
 388
 389   /* if we are registering a block, make sure there is a specified sub-table */
 390   if (!ent || !name || ((type == SILC_CONFIG_ARG_BLOCK) && !subtable))
 391     return FALSE;
 392
 393   /* don't register a reserved tag */
 394   if (!strcasecmp(name, "include"))
 395     return FALSE;
 396
 397   /* check if an option was previously registered */
 398   if (silc_config_find_option(ent, name)) {
 399     SILC_LOG_DEBUG(("Error: Can't register \"%s\" twice.", name));
 400     return FALSE;
 401   }
 402
 403   /* allocate and append the new option */
 404   newopt = silc_calloc(1, sizeof(*newopt));
 405   newopt->name = strdup(name);
 406   newopt->type = type;
 407   newopt->cb = cb;
 408   newopt->subtable = subtable;
 409   newopt->context = context;
 410
 411   /* append this option to the list */
 412   if (!ent->opts)
 413     ent->opts = newopt;
 414   else {
 415     SilcConfigOption *tmp;
 416     for (tmp = ent->opts; tmp->next; tmp = tmp->next);
 417     tmp->next = newopt;
 418   }
 419   return TRUE;
 420 }
 421
 422 /* Register a new option table in the specified config entity */
 423
 424 bool silc_config_register_table(SilcConfigEntity ent,
 425                                 const SilcConfigTable table[], void *context)
 426 {
 427   int i;
 428   if (!ent || !table)
 429     return FALSE;
 430   SILC_CONFIG_DEBUG(("Registering table"));
 431   /* XXX FIXME: some potability checks needed - really? */
 432   for (i = 0; table[i].name; i++) {
 433     if (!silc_config_register(ent, table[i].name, table[i].type,
 434                               table[i].callback, table[i].subtable, context))
 435       return FALSE;
 436   }
 437   return TRUE;
 438 }
 439
 440 /* ... */
 441
 442 static int silc_config_main_internal(SilcConfigEntity ent)
 443 {
 444   SilcConfigFile *file = ent->file;
 445   char **p = &file->p;
 446
 447   /* loop throught statements */
 448   while (1) {
 449     char buf[255];
 450     SilcConfigOption *thisopt;
 451
 452     /* makes it pointing to the next interesting char */
 453     my_skip_comments(file);
 454     /* got eof? */
 455     if (**p == '\0' || **p == EOF) {
 456       if (file->level > 1) /* cannot get eof in a sub-level! */
 457         return SILC_CONFIG_EEXPECTED;
 458       goto finish;
 459     }
 460     /* check if we completed this (sub) section (it doesn't matter if this
 461      * is the main section) */
 462     if (**p == '}') {
 463       if (file->level < 2) /* can't be! must be at least one sub-block */
 464         return SILC_CONFIG_EUNEXPECTED;
 465       (*p)++;
 466       goto finish;
 467     }
 468     //SILC_LOG_HEXDUMP(("Preparing lookup at line=%lu", file->line), *p, 16);
 469
 470     /* obtain the keyword */
 471     my_next_token(file, buf);
 472     SILC_CONFIG_DEBUG(("Looking up keyword=\"%s\" [line=%lu]", buf, file->line));
 473
 474     /* handle special directive */
 475     if (!strcasecmp(buf, "include")) {
 476       int ret;
 477       SilcConfigFile *inc_file;
 478       SilcConfigEntity inc_ent;
 479
 480       my_trim_spaces(file); /* prepare next char */
 481
 482       /* Now trying to include the specified file.  The included file will
 483        * be allowed to include sub-files but it will preserve the block-level
 484        * of the including block. Note that the included file won't be allowed
 485        * to raise the block level of the including block. */
 486
 487       my_get_string(file, buf); /* get the filename */
 488       SILC_LOG_DEBUG(("Including file \"%s\"", buf));
 489       /* before getting on, check if this row is REALLY complete */
 490       if (*(*p)++ != ';')
 491         return SILC_CONFIG_EMISSCOLON;
 492
 493       /* open the file and start the parsing */
 494       inc_file = silc_config_open(buf);
 495       if (!inc_file) /* does it point a valid filename? */
 496         return SILC_CONFIG_ECANTOPEN;
 497       inc_file->included = TRUE;
 498
 499       /* create a new entity and hack it to use the same options */
 500       inc_ent = silc_config_init(inc_file);
 501       inc_ent->opts = ent->opts;
 502       ret = silc_config_main(inc_ent);
 503
 504       /* Cleanup.
 505        * If the included file returned an error, the application will probably
 506        * want to output some kind of error message. Because of this, we can't
 507        * destroy THIS file object. The hack works this way: The application
 508        * expects to destroy the originally created object file, so we'll swap
 509        * the original file with the included file. */
 510       if (ret) {
 511         SilcConfigFile tmp_file;
 512         SILC_CONFIG_DEBUG(("SWAPPING FILE OBJECTS"));
 513         memcpy(&tmp_file, inc_file, sizeof(tmp_file));
 514         memcpy(inc_file, file, sizeof(tmp_file));
 515         silc_config_close(inc_file);
 516         memcpy(file, &tmp_file, sizeof(tmp_file));
 517         return ret;
 518       }
 519       /* otherwise if no errors encoured, continue normally */
 520       silc_config_close(inc_file);
 521       continue; /* this one is handled */
 522     }
 523
 524     /* we have a registered option (it can also be a sub-block) */
 525     thisopt = silc_config_find_option(ent, buf);
 526     if (!thisopt)
 527       return SILC_CONFIG_EBADOPTION;
 528
 529     my_trim_spaces(file); /* prepare next char */
 530
 531     /* option type is a block? */
 532     if (thisopt->type == SILC_CONFIG_ARG_BLOCK) {
 533       int ret;
 534       SilcConfigEntity sub_ent;
 535
 536       SILC_CONFIG_DEBUG(("Entering sub-block"));
 537       if (*(*p)++ != '{')
 538         return SILC_CONFIG_EOPENBRACE;
 539       /* build the new entity for this sub-block */
 540       sub_ent = silc_config_init(ent->file);
 541       /* use the previous specified table to describe this block's options */
 542       silc_config_register_table(sub_ent, thisopt->subtable, thisopt->context);
 543       /* run this block! */
 544       ret = silc_config_main(sub_ent);
 545       SILC_CONFIG_DEBUG(("Returned from sub-block [ret=%d]", ret));
 546
 547       if (ret) /* now check the result */
 548         return ret;
 549
 550       /* now call block clean-up callback (if any) */
 551       if (thisopt->cb) {
 552         int ret;
 553         SILC_CONFIG_DEBUG(("Now calling clean-up callback"));
 554         ret = thisopt->cb(thisopt->type, thisopt->name, file->line, NULL,
 555                           thisopt->context);
 556         if (ret) {
 557           SILC_CONFIG_DEBUG(("Callback refused the value [ret=%d]", ret));
 558           return ret;
 559         }
 560       }
 561       /* Do we want ';' to be mandatory after close brace? */
 562       if (*(*p)++ != ';')
 563         return SILC_CONFIG_EMISSCOLON;
 564     }
 565     else if (thisopt->type == SILC_CONFIG_ARG_NONE) {
 566       /* before getting on, check if this row is REALLY complete */
 567       if (*(*p)++ != ';')
 568         return SILC_CONFIG_EMISSCOLON;
 569       SILC_CONFIG_DEBUG(("Triggering callback for none"));
 570       if (thisopt->cb) {
 571         thisopt->cb(thisopt->type, thisopt->name, file->line,
 572                     NULL, thisopt->context);
 573       }
 574     }
 575     else {
 576       void *pt;
 577       int ret;
 578
 579       if (*(*p)++ != '=')
 580         return SILC_CONFIG_EEXPECTEDEQUAL;
 581
 582       my_get_string(file, buf); /* get the option argument */
 583       SILC_CONFIG_DEBUG(("With argument=\"%s\"", buf));
 584
 585       /* before getting on, check if this row is REALLY complete */
 586       if (*(*p)++ != ';')
 587         return SILC_CONFIG_EMISSCOLON;
 588
 589       /* convert the option argument to the right format */
 590       pt = silc_config_marshall(thisopt->type, buf);
 591       if (!pt)
 592         return SILC_CONFIG_EINVALIDTEXT;
 593       if (thisopt->cb) {
 594         ret = thisopt->cb(thisopt->type, thisopt->name, file->line,
 595                           pt, thisopt->context);
 596         if (ret) {
 597           SILC_CONFIG_DEBUG(("Callback refused the value [ret=%d]", ret));
 598           return ret;
 599         }
 600       }
 601       silc_free(pt);
 602     }
 603     continue;
 604
 605  finish:
 606     break;
 607   }
 608
 609   return SILC_CONFIG_OK;
 610 }
 611
 612 /* ... */
 613
 614 int silc_config_main(SilcConfigEntity ent)
 615 {
 616   SilcConfigFile *file = ent->file;
 617   int ret;
 618
 619   /* don't silently accept a NULL entity */
 620   if (!ent) {
 621     ret = SILC_CONFIG_EGENERIC;
 622     goto main_cleanup;
 623   }
 624
 625   /* call the real main and store the result */
 626   file->level++;
 627   SILC_CONFIG_DEBUG(("[Lev=%d] Entering config parsing core", file->level));
 628   ret = silc_config_main_internal(ent);
 629   SILC_CONFIG_DEBUG(("[Lev=%d] Quitting main [ret=%d]", file->level, ret));
 630   if (!file->level) /* when swap happens, we could close a file twice */
 631     goto main_end;
 632   file->level--;
 633
 634   /* If this file was included don't destroy the options set because it is
 635    * the same of the including block. Although if this entity is in a
 636    * sub-block created inside the included file, this options set must be
 637    * destroyed. */
 638  main_cleanup:
 639   if ((file->level != 0) || (file->included != TRUE))
 640     silc_config_destroy(ent, TRUE);
 641   else
 642     silc_config_destroy(ent, FALSE);
 643
 644  main_end:
 645   return ret;
 646 }