lib/conf2.c

   1 /*
   2  *      UCW Library -- Reading of configuration files
   3  *
   4  *      (c) 2001--2006 Robert Spalek <robert@ucw.cz>
   5  *      (c) 2003--2006 Martin Mares <mj@ucw.cz>
   6  *
   7  *      This software may be freely distributed and used according to the terms
   8  *      of the GNU Lesser General Public License.
   9  */
  10
  11 #include "lib/lib.h"
  12 #include "lib/conf2.h"
  13 #include "lib/mempool.h"
  14 #include "lib/clists.h"
  15
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <errno.h>
  19
  20 /* Memory allocation */
  21
  22 struct mempool *cf_pool;        // current pool for loading new configuration
  23 static struct old_pools {
  24   struct old_pools *prev;
  25   struct mempool *pool;
  26 } *pools;                       // link-list of older cf_pool's
  27
  28 void *
  29 cf_malloc(uns size)
  30 {
  31   return mp_alloc(cf_pool, size);
  32 }
  33
  34 void *
  35 cf_malloc_zero(uns size)
  36 {
  37   return mp_alloc_zero(cf_pool, size);
  38 }
  39
  40 byte *
  41 cf_strdup(byte *s)
  42 {
  43   return mp_strdup(cf_pool, s);
  44 }
  45
  46 byte *
  47 cf_printf(char *fmt, ...)
  48 {
  49   va_list args;
  50   va_start(args, fmt);
  51   byte *res = mp_vprintf(cf_pool, fmt, args);
  52   va_end(args);
  53   return res;
  54 }
  55
  56 /* Undo journal */
  57
  58 uns cf_need_journal;            // some programs do not need journal
  59 static struct journal_item {
  60   struct journal_item *prev;
  61   byte *ptr;
  62   uns len;
  63   byte copy[0];
  64 } *journal;
  65
  66 void
  67 cf_journal_block(void *ptr, uns len)
  68 {
  69   if (!cf_need_journal)
  70     return;
  71   struct journal_item *ji = cf_malloc(sizeof(struct journal_item) + len);
  72   ji->prev = journal;
  73   ji->ptr = ptr;
  74   ji->len = len;
  75   memcpy(ji->copy, ptr, len);
  76   journal = ji;
  77 }
  78
  79 static void
  80 journal_swap(void)
  81   // swaps the contents of the memory and the journal, and reverses the list
  82 {
  83   struct journal_item *curr, *prev, *next;
  84   for (next=NULL, curr=journal; curr; next=curr, curr=prev)
  85   {
  86     prev = curr->prev;
  87     curr->prev = next;
  88     for (uns i=0; i<curr->len; i++)
  89     {
  90       byte x = curr->copy[i];
  91       curr->copy[i] = curr->ptr[i];
  92       curr->ptr[i] = x;
  93     }
  94   }
  95   journal = next;
  96 }
  97
  98 static struct journal_item *
  99 journal_new_section(uns new_pool)
 100 {
 101   if (new_pool)
 102     cf_pool = mp_new(1<<14);
 103   struct journal_item *oldj = journal;
 104   journal = NULL;
 105   return oldj;
 106 }
 107
 108 static void
 109 journal_commit_section(uns new_pool, struct journal_item *oldj)
 110 {
 111   if (new_pool)
 112   {
 113     struct old_pools *p = cf_malloc(sizeof(struct old_pools));
 114     p->prev = pools;
 115     p->pool = cf_pool;
 116     pools = p;
 117   }
 118   if (oldj)
 119   {
 120     struct journal_item **j = &journal;
 121     while (*j)
 122       j = &(*j)->prev;
 123     *j = oldj;
 124   }
 125 }
 126
 127 static void
 128 journal_rollback_section(uns new_pool, struct journal_item *oldj, byte *msg)
 129 {
 130   if (!cf_need_journal)
 131     die("Cannot rollback the configuration, because the journal is disabled.  Error: %s", msg);
 132   journal_swap();
 133   journal = oldj;
 134   if (new_pool)
 135   {
 136     mp_delete(cf_pool);
 137     cf_pool = pools ? pools->pool : NULL;
 138   }
 139 }
 140
 141 /* Initialization */
 142
 143 static struct cf_section sections;      // root section
 144
 145 static struct cf_item *
 146 find_subitem(struct cf_section *sec, byte *name)
 147 {
 148   struct cf_item *ci = sec->cfg;
 149   for (; ci->cls; ci++)
 150     if (!strcasecmp(ci->name, name))
 151       return ci;
 152   return ci;
 153 }
 154
 155 void
 156 cf_declare_section(byte *name, struct cf_section *sec)
 157 {
 158   if (!sections.cfg)
 159   {
 160     sections.size = 50;
 161     sections.cfg = xmalloc_zero(sections.size * sizeof(struct cf_item));
 162   }
 163   struct cf_item *ci = find_subitem(&sections, name);
 164   if (ci->cls)
 165     die("Cannot register section %s twice", name);
 166   ci->cls = CC_SECTION;
 167   ci->name = name;
 168   ci->number = 1;
 169   ci->ptr = NULL;
 170   ci->u.sec = sec;
 171   ci++;
 172   if (ci - sections.cfg >= (int) sections.size)
 173   {
 174     sections.cfg = xrealloc(sections.cfg, 2*sections.size * sizeof(struct cf_item));
 175     bzero(sections.cfg + sections.size, sections.size * sizeof(struct cf_item));
 176     sections.size *= 2;
 177   }
 178 }
 179
 180 void
 181 cf_init_section(byte *name, struct cf_section *sec, void *ptr)
 182 {
 183   if (sec->size)
 184     bzero(ptr, sec->size);
 185   for (uns i=0; sec->cfg[i].cls; i++)
 186     if (sec->cfg[i].cls == CC_SECTION)
 187       cf_init_section(sec->cfg[i].name, sec->cfg[i].u.sec, ptr + (addr_int_t) sec->cfg[i].ptr);
 188     else if (sec->cfg[i].cls == CC_LIST)
 189       clist_init(sec->cfg[i].ptr);
 190   byte *msg = sec->init(ptr);
 191   if (msg)
 192     die("Cannot initialize section %s: %s", name, msg);
 193 }
 194
 195 static void
 196 global_init(void)
 197 {
 198   for (struct cf_item *ci=sections.cfg; ci->cls; ci++)
 199     cf_init_section(ci->name, ci->u.sec, NULL);
 200 }
 201
 202 static struct cf_item *
 203 find_item(struct cf_section *curr_sec, byte *name, byte **msg)
 204 {
 205   *msg = NULL;
 206   if (name[0] == '.')
 207     name++;
 208   else if (strchr(name, '.'))
 209     curr_sec = &sections;
 210   if (!curr_sec)
 211     return NULL;
 212   byte *c;
 213   while ((c = strchr(name, '.')))
 214   {
 215     *c++ = 0;
 216     struct cf_item *ci = find_subitem(curr_sec, name);
 217     if (ci->cls != CC_SECTION)
 218     {
 219       *msg = cf_printf("Item %s %s", name, !ci->cls ? "does not exist" : "is not a subsection");
 220       return NULL;
 221     }
 222     curr_sec = ci->u.sec;
 223     name = c;
 224   }
 225   struct cf_item *ci = find_subitem(curr_sec, name);
 226   if (!ci->cls)
 227   {
 228     *msg = "Unknown item";
 229     return NULL;
 230   }
 231   return ci;
 232 }
 233
 234 /* Safe loading and reloading */
 235
 236 byte *cf_def_file = DEFAULT_CONFIG;
 237
 238 #ifndef DEFAULT_CONFIG
 239 #define DEFAULT_CONFIG NULL
 240 #endif
 241
 242 byte *cfdeffile = DEFAULT_CONFIG;
 243
 244 static byte *load_file(byte *file);
 245 static byte *load_string(byte *string);
 246
 247 byte *
 248 cf_reload(byte *file)
 249 {
 250   journal_swap();
 251   struct journal_item *oldj = journal_new_section(1);
 252   byte *msg = load_file(file);
 253   if (!msg)
 254   {
 255     for (struct old_pools *p=pools; p; p=pools)
 256     {
 257       pools = p->prev;
 258       mp_delete(p->pool);
 259     }
 260     journal_commit_section(1, NULL);
 261   }
 262   else
 263   {
 264     journal_rollback_section(1, oldj, msg);
 265     journal_swap();
 266   }
 267   return msg;
 268 }
 269
 270 byte *
 271 cf_load(byte *file)
 272 {
 273   struct journal_item *oldj = journal_new_section(1);
 274   byte *msg = load_file(file);
 275   if (!msg)
 276     journal_commit_section(1, oldj);
 277   else
 278     journal_rollback_section(1, oldj, msg);
 279   return msg;
 280 }
 281
 282 byte *
 283 cf_set(byte *string)
 284 {
 285   struct journal_item *oldj = journal_new_section(0);
 286   byte *msg = load_string(string);
 287   if (!msg)
 288     journal_commit_section(0, oldj);
 289   else
 290     journal_rollback_section(0, oldj, msg);
 291   return msg;
 292 }
 293
 294 /* Parsers for standard types */
 295
 296 struct unit {
 297   uns name;                     // one-letter name of the unit
 298   uns num, den;                 // fraction
 299 };
 300
 301 static const struct unit units[] = {
 302   { 'd', 86400, 1 },
 303   { 'h', 3600, 1 },
 304   { 'k', 1000, 1 },
 305   { 'm', 1000000, 1 },
 306   { 'g', 1000000000, 1 },
 307   { 'K', 1024, 1 },
 308   { 'M', 1048576, 1 },
 309   { 'G', 1073741824, 1 },
 310   { '%', 1, 100 },
 311   { 0, 0, 0 }
 312 };
 313
 314 static const struct unit *
 315 lookup_unit(byte *value, byte *end, byte **msg)
 316 {
 317   if (end && *end) {
 318     if (end == value || end[1] || *end >= '0' && *end <= '9')
 319       *msg = "Invalid number";
 320     else {
 321       for (const struct unit *u=units; u->name; u++)
 322         if (u->name == *end)
 323           return u;
 324       *msg = "Invalid unit";
 325     }
 326   }
 327   return NULL;
 328 }
 329
 330 static char cf_rngerr[] = "Number out of range";
 331
 332 byte *
 333 cf_parse_int(byte *str, int *ptr)
 334 {
 335   byte *msg = NULL;
 336   if (!*str)
 337     msg = "Missing number";
 338   else {
 339     const struct unit *u;
 340     char *end;
 341     errno = 0;
 342     uns x = strtoul(str, &end, 0);
 343     if (errno == ERANGE)
 344       msg = cf_rngerr;
 345     else if (u = lookup_unit(str, end, &msg)) {
 346       u64 y = (u64)x * u->num;
 347       if (y % u->den)
 348         msg = "Number is not an integer";
 349       else {
 350         y /= u->den;
 351         if (y > 0xffffffff)
 352           msg = cf_rngerr;
 353         *ptr = y;
 354       }
 355     } else
 356       *ptr = x;
 357   }
 358   return msg;
 359 }
 360
 361 byte *
 362 cf_parse_u64(byte *str, u64 *ptr)
 363 {
 364   byte *msg = NULL;
 365   if (!*str)
 366     msg = "Missing number";
 367   else {
 368     const struct unit *u;
 369     char *end;
 370     errno = 0;
 371     u64 x = strtoull(str, &end, 0);
 372     if (errno == ERANGE)
 373       msg = cf_rngerr;
 374     else if (u = lookup_unit(str, end, &msg)) {
 375       if (x > ~(u64)0 / u->num)
 376         msg = "Number out of range";
 377       else {
 378         x *= u->num;
 379         if (x % u->den)
 380           msg = "Number is not an integer";
 381         else
 382           *ptr = x / u->den;
 383       }
 384     } else
 385       *ptr = x;
 386   }
 387   return msg;
 388 }
 389
 390 byte *
 391 cf_parse_double(byte *str, double *ptr)
 392 {
 393   byte *msg = NULL;
 394   if (!*str)
 395     msg = "Missing number";
 396   else {
 397     const struct unit *u;
 398     char *end;
 399     errno = 0;
 400     double x = strtoul(str, &end, 0);
 401     if (errno == ERANGE)
 402       msg = cf_rngerr;
 403     else if (u = lookup_unit(str, end, &msg))
 404       *ptr = x * u->num / u->den;
 405     else
 406       *ptr = x;
 407   }
 408   return msg;
 409 }
 410
 411 static byte *
 412 cf_parse_string(byte *str, byte **ptr)
 413 {
 414   *ptr = cf_strdup(str);
 415   return NULL;
 416 }
 417
 418 /* Register size of and parser for each basic type */
 419
 420 typedef byte *cf_basic_parser(byte *str, void *ptr);
 421 static struct {
 422   uns size;
 423   void *parser;
 424 } parsers[] = {
 425   { sizeof(int), cf_parse_int },
 426   { sizeof(u64), cf_parse_u64 },
 427   { sizeof(double), cf_parse_double },
 428   { sizeof(byte*), cf_parse_string }
 429 };
 430
 431 static byte *
 432 cf_parse_ary(uns number, byte **pars, void *ptr, enum cf_type type)
 433 {
 434   for (uns i=0; i<number; i++)
 435   {
 436     byte *msg = ((cf_basic_parser*) parsers[type].parser) (pars[i], ptr + i * parsers[type].size);
 437     if (msg)
 438       return cf_printf("Cannot parse item %d: %s", i+1, msg);
 439   }
 440   return NULL;
 441 }
 442
 443 /* Interpreter */
 444
 445 enum operation {
 446   OP_CLEAR,                     // list
 447   OP_SET,                       // basic attribute (static, dynamic, parsed), section, list
 448   OP_APPEND,                    // dynamic array, list
 449   OP_PREPEND,                   // dynamic array, list
 450   OP_REMOVE,                    // list
 451   OP_OPEN = 0x80                // here we only have an opening brace
 452 };
 453
 454 #define MAX_STACK_SIZE  100
 455 static struct item_stack {
 456   struct cf_section *sec;       // nested section
 457   void *base_ptr;               // because original pointers are often relative
 458   enum operation op;            // it is performed when a closing brace is encountered
 459 } stack[MAX_STACK_SIZE];
 460 static uns level;
 461
 462 static byte *
 463 parse_dynamic(struct cf_item *item, int number, byte **pars, void **ptr)
 464 {
 465   enum cf_type type = item->u.type;
 466   if (number > item->number)
 467     return "Expecting shorter array";
 468   cf_journal_block(ptr, sizeof(void*));
 469   *ptr = cf_malloc((number+1) * parsers[type].size) + parsers[type].size;
 470   * (uns*) (*ptr - parsers[type].size) = number;
 471   return cf_parse_ary(number, pars, *ptr, type);
 472 }
 473
 474 static byte *
 475 add_to_dynamic(struct cf_item *item, int number, byte **pars, void **ptr, enum operation op)
 476 {
 477   enum cf_type type = item->u.type;
 478   void *old_p = *ptr;
 479   int old_nr = * (int*) (old_p - parsers[type].size);
 480   if (old_nr + number > item->number)
 481     return "Cannot enlarge dynamic array";
 482   // stretch the dynamic array
 483   void *new_p = cf_malloc((old_nr + number + 1) * parsers[type].size) + parsers[type].size;
 484   * (uns*) (new_p - parsers[type].size) = old_nr + number;
 485   cf_journal_block(ptr, sizeof(void*));
 486   *ptr = new_p;
 487   if (op == OP_APPEND)
 488   {
 489     memcpy(new_p, old_p, old_nr * parsers[type].size);
 490     return cf_parse_ary(number, pars, new_p + old_nr * parsers[type].size, type);
 491   }
 492   else if (op == OP_PREPEND)
 493   {
 494     memcpy(new_p + number * parsers[type].size, old_p, old_nr * parsers[type].size);
 495     return cf_parse_ary(number, pars, new_p, type);
 496   }
 497   else
 498     ASSERT(0);
 499 }
 500
 501 static byte *
 502 parse_subsection(struct cf_section *sec, int number, byte **pars, void *ptr)
 503 {
 504   struct cf_item *ci;
 505   for (ci=sec->cfg; ci->cls; ci++)
 506   {
 507     if (ci->cls == CC_DYNAMIC && !ci[1].cls)
 508       break;
 509     if (ci->cls != CC_STATIC)
 510       return "Only sections consisting entirely of basic attributes can be written on 1 line";
 511     if (number)
 512     {
 513       if (number < ci->number)
 514         return "The number of parameters does not fit the section attributes";
 515       void *p = ptr + (addr_int_t) ci->ptr;
 516       cf_journal_block(p, ci->number * parsers[ci->u.type].size);
 517       byte *msg = cf_parse_ary(ci->number, pars, p, ci->u.type);
 518       if (msg)
 519         return cf_printf("Attribute %s: %s", ci->name, msg);
 520       number -= ci->number;
 521       pars += ci->number;
 522     }
 523   }
 524   if (ci->cls == CC_DYNAMIC)
 525     return parse_dynamic(ci, number, pars, ptr + (addr_int_t) ci->ptr);
 526   else if (number)
 527     return "Too many parameters for this section";
 528   return NULL;
 529 }
 530
 531 static void
 532 add_to_list(struct clist *list, struct cnode *node, enum operation op)
 533 {
 534   cf_journal_block(list, sizeof(struct clist));
 535   if (op == OP_APPEND || op == OP_SET)
 536     clist_add_tail(list, node);
 537   else if (op == OP_PREPEND)
 538     clist_add_head(list, node);
 539   else
 540     ASSERT(0);
 541 }
 542
 543 static byte *
 544 increase_stack(struct cf_item *item, enum operation op)
 545 {
 546   if (level >= MAX_STACK_SIZE-1)
 547     return "Too many nested sections";
 548   ++level;
 549   if (item)                     // fill in the base pointer
 550   {
 551     if (item->cls == CC_SECTION)
 552       stack[level].base_ptr = stack[level].base_ptr + (addr_int_t) item->ptr;
 553     else if (item->cls != CC_LIST)
 554     {
 555       stack[level].base_ptr = cf_malloc(item->u.sec->size);
 556       cf_init_section(item->name, item->u.sec, stack[level].base_ptr);
 557     }
 558     else
 559       return "Opening brace can only be used on sections and lists";
 560     stack[level].sec = item->u.sec;
 561   }
 562   else                          // unknown is also handled here, since we need to trace recursion
 563   {
 564     stack[level].base_ptr = NULL;
 565     stack[level].sec = NULL;
 566   }
 567   stack[level].op = op;
 568   return NULL;
 569 }
 570
 571 static byte *
 572 interpret_item(byte *name, enum operation op, int number, byte **pars)
 573 {
 574   byte *msg;
 575   struct cf_item *item = find_item(stack[level].sec, name, &msg);
 576   if (op & OP_OPEN)             // the operation will be performed after the closing brace
 577     return increase_stack(item, op) ? : msg;
 578   if (!item)
 579     return msg;
 580
 581   void *ptr = stack[level].base_ptr + (addr_int_t) item->ptr;
 582   if (op == OP_CLEAR)           // clear link-list
 583   {
 584     if (item->cls != CC_LIST)
 585       return "The item is not a list";
 586     cf_journal_block(ptr, sizeof(struct clist));
 587     clist_init(ptr);
 588   }
 589   else if (op == OP_SET && item->cls != CC_LIST)
 590     switch (item->cls)          // setting regular variables
 591     {
 592       case CC_STATIC:
 593         if (number != item->number)
 594           return item->number==1 ? "Expecting one scalar value, not an array" : "Expecting array of different length";
 595         cf_journal_block(ptr, number * parsers[item->u.type].size);
 596         return cf_parse_ary(number, pars, ptr, item->u.type);
 597       case CC_DYNAMIC:
 598         return parse_dynamic(item, number, pars, ptr);
 599       case CC_PARSER:
 600         if (item->number >= 0)
 601         {
 602           if (number != item->number)
 603             return "Expecting different number of parameters";
 604         } else {
 605           if (number > -item->number)
 606             return "Expecting less parameters";
 607         }
 608         for (int i=0; i<number; i++)
 609           pars[i] = cf_strdup(pars[i]);
 610         return item->u.par(number, pars, ptr);
 611       case CC_SECTION:          // setting a subsection at once
 612         return parse_subsection(item->u.sec, number, pars, ptr);
 613       default:
 614         ASSERT(0);
 615     }
 616   else if (item->cls == CC_DYNAMIC)
 617     return add_to_dynamic(item, number, pars, ptr, op);
 618   else if (item->cls == CC_LIST)
 619   {                             // adding to a list at once
 620     void *node = cf_malloc(item->u.sec->size);
 621     cf_init_section(item->name, item->u.sec, node);
 622     msg = parse_subsection(item->u.sec, number, pars, node);
 623     if (msg)
 624       return msg;
 625     add_to_list(ptr, node, op);
 626   }
 627   else
 628     ASSERT(0);
 629   return NULL;
 630 }
 631