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 #include "lib/fastbuf.h"
  16 #include "lib/chartype.h"
  17 #include "lib/lfs.h"
  18 #include "lib/stkstring.h"
  19 #include "lib/binsearch.h"
  20
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <errno.h>
  24 #include <stdarg.h>
  25 #include <fcntl.h>
  26 #include <getopt.h>
  27
  28 #define TRY(f)  do { byte *_msg = f; if (_msg) return _msg; } while (0)
  29
  30 /* Memory allocation */
  31
  32 struct mempool *cf_pool;        // current pool for loading new configuration
  33 static struct old_pools {
  34   struct old_pools *prev;
  35   struct mempool *pool;
  36 } *pools;                       // link-list of older cf_pool's
  37
  38 void *
  39 cf_malloc(uns size)
  40 {
  41   return mp_alloc(cf_pool, size);
  42 }
  43
  44 void *
  45 cf_malloc_zero(uns size)
  46 {
  47   return mp_alloc_zero(cf_pool, size);
  48 }
  49
  50 byte *
  51 cf_strdup(byte *s)
  52 {
  53   return mp_strdup(cf_pool, s);
  54 }
  55
  56 byte *
  57 cf_printf(char *fmt, ...)
  58 {
  59   va_list args;
  60   va_start(args, fmt);
  61   byte *res = mp_vprintf(cf_pool, fmt, args);
  62   va_end(args);
  63   return res;
  64 }
  65
  66 /* Undo journal */
  67
  68 uns cf_need_journal = 1;        // some programs do not need journal
  69 static struct journal_item {
  70   struct journal_item *prev;
  71   byte *ptr;
  72   uns len;
  73   byte copy[0];
  74 } *journal;
  75
  76 void
  77 cf_journal_block(void *ptr, uns len)
  78 {
  79   if (!cf_need_journal)
  80     return;
  81   struct journal_item *ji = cf_malloc(sizeof(struct journal_item) + len);
  82   ji->prev = journal;
  83   ji->ptr = ptr;
  84   ji->len = len;
  85   memcpy(ji->copy, ptr, len);
  86   journal = ji;
  87 }
  88
  89 static void
  90 journal_swap(void)
  91   // swaps the contents of the memory and the journal, and reverses the list
  92 {
  93   struct journal_item *curr, *prev, *next;
  94   for (next=NULL, curr=journal; curr; next=curr, curr=prev)
  95   {
  96     prev = curr->prev;
  97     curr->prev = next;
  98     for (uns i=0; i<curr->len; i++)
  99     {
 100       byte x = curr->copy[i];
 101       curr->copy[i] = curr->ptr[i];
 102       curr->ptr[i] = x;
 103     }
 104   }
 105   journal = next;
 106 }
 107
 108 static struct journal_item *
 109 journal_new_transaction(uns new_pool)
 110 {
 111   if (new_pool)
 112     cf_pool = mp_new(1<<10);
 113   struct journal_item *oldj = journal;
 114   journal = NULL;
 115   return oldj;
 116 }
 117
 118 static void
 119 journal_commit_transaction(uns new_pool, struct journal_item *oldj)
 120 {
 121   if (new_pool)
 122   {
 123     struct old_pools *p = cf_malloc(sizeof(struct old_pools));
 124     p->prev = pools;
 125     p->pool = cf_pool;
 126     pools = p;
 127   }
 128   if (oldj)
 129   {
 130     struct journal_item **j = &journal;
 131     while (*j)
 132       j = &(*j)->prev;
 133     *j = oldj;
 134   }
 135 }
 136
 137 static void
 138 journal_rollback_transaction(uns new_pool, struct journal_item *oldj)
 139 {
 140   if (!cf_need_journal)
 141     die("Cannot rollback the configuration, because the journal is disabled.");
 142   journal_swap();
 143   journal = oldj;
 144   if (new_pool)
 145   {
 146     mp_delete(cf_pool);
 147     cf_pool = pools ? pools->pool : NULL;
 148   }
 149 }
 150
 151 /* Dirty sections */
 152
 153 struct dirty_section {
 154   struct cf_section *sec;
 155   void *ptr;
 156 };
 157 #define GBUF_TYPE       struct dirty_section
 158 #define GBUF_PREFIX(x)  dirtsec_##x
 159 #include "lib/gbuf.h"
 160 static dirtsec_t dirty;
 161 static uns dirties;
 162 static uns everything_committed;                // after the 1st load, this flag is set on
 163
 164 static void
 165 add_dirty(struct cf_section *sec, void *ptr)
 166 {
 167   dirtsec_grow(&dirty, dirties+1);
 168   struct dirty_section *dest = dirty.ptr + dirties;
 169   if (dirties && dest[-1].sec == sec && dest[-1].ptr == ptr)
 170     return;
 171   dest->sec = sec;
 172   dest->ptr = ptr;
 173   dirties++;
 174 }
 175
 176 #define ASORT_PREFIX(x) dirtsec_##x
 177 #define ASORT_KEY_TYPE  struct dirty_section
 178 #define ASORT_ELT(i)    dirty.ptr[i]
 179 #define ASORT_LT(x,y)   x.sec < y.sec || x.sec == y.sec && x.ptr < y.ptr
 180 #include "lib/arraysort.h"
 181
 182 static void
 183 sort_dirty(void)
 184 {
 185   if (dirties <= 1)
 186     return;
 187   dirtsec_sort(dirties);
 188   struct dirty_section *read = dirty.ptr + 1, *write = dirty.ptr + 1, *limit = dirty.ptr + dirties;
 189   while (read < limit) {
 190     if (read->sec != read[-1].sec || read->ptr != read[-1].ptr) {
 191       if (read != write)
 192         *write = *read;
 193       write++;
 194     }
 195     read++;
 196   }
 197   dirties = write - dirty.ptr;
 198 }
 199
 200 /* Initialization */
 201
 202 #define SEC_FLAG_DYNAMIC        0x80000000      // contains a dynamic attribute
 203 #define SEC_FLAG_UNKNOWN        0x40000000      // ignore unknown entriies
 204 #define SEC_FLAG_NUMBER         0x0fffffff      // number of entries
 205
 206 static struct cf_section sections;      // root section
 207
 208 static struct cf_item *
 209 find_subitem(struct cf_section *sec, byte *name)
 210 {
 211   struct cf_item *ci = sec->cfg;
 212   for (; ci->cls; ci++)
 213     if (!strcasecmp(ci->name, name))
 214       return ci;
 215   return ci;
 216 }
 217
 218 static void
 219 inspect_section(struct cf_section *sec)
 220 {
 221   sec->flags = 0;
 222   struct cf_item *ci;
 223   for (ci=sec->cfg; ci->cls; ci++)
 224     if (ci->cls == CC_SECTION) {
 225       inspect_section(ci->u.sec);
 226       sec->flags |= ci->u.sec->flags & SEC_FLAG_DYNAMIC;
 227     } else if (ci->cls == CC_LIST) {
 228       inspect_section(ci->u.sec);
 229       sec->flags |= SEC_FLAG_DYNAMIC;
 230     } else if (ci->cls == CC_DYNAMIC || ci->cls == CC_PARSER && ci->number < 0)
 231       sec->flags |= SEC_FLAG_DYNAMIC;
 232   sec->flags |= ci - sec->cfg;          // record the number of entries
 233 }
 234
 235 void
 236 cf_declare_section(byte *name, struct cf_section *sec, uns allow_unknown)
 237 {
 238   if (!sections.cfg)
 239   {
 240     sections.size = 50;
 241     sections.cfg = xmalloc_zero(sections.size * sizeof(struct cf_item));
 242   }
 243   struct cf_item *ci = find_subitem(&sections, name);
 244   if (ci->cls)
 245     die("Cannot register section %s twice", name);
 246   ci->cls = CC_SECTION;
 247   ci->name = name;
 248   ci->number = 1;
 249   ci->ptr = NULL;
 250   ci->u.sec = sec;
 251   inspect_section(sec);
 252   if (allow_unknown)
 253     sec->flags |= SEC_FLAG_UNKNOWN;
 254   ci++;
 255   if (ci - sections.cfg >= (int) sections.size)
 256   {
 257     sections.cfg = xrealloc(sections.cfg, 2*sections.size * sizeof(struct cf_item));
 258     bzero(sections.cfg + sections.size, sections.size * sizeof(struct cf_item));
 259     sections.size *= 2;
 260   }
 261 }
 262
 263 void
 264 cf_init_section(byte *name, struct cf_section *sec, void *ptr, uns do_bzero)
 265 {
 266   if (do_bzero) {
 267     ASSERT(sec->size);
 268     bzero(ptr, sec->size);
 269   }
 270   for (uns i=0; sec->cfg[i].cls; i++)
 271     if (sec->cfg[i].cls == CC_SECTION)
 272       cf_init_section(sec->cfg[i].name, sec->cfg[i].u.sec, ptr + (addr_int_t) sec->cfg[i].ptr, 0);
 273     else if (sec->cfg[i].cls == CC_LIST)
 274       clist_init(ptr + (addr_int_t) sec->cfg[i].ptr);
 275   if (sec->init) {
 276     byte *msg = sec->init(ptr);
 277     if (msg)
 278       die("Cannot initialize section %s: %s", name, msg);
 279   }
 280 }
 281
 282 static void
 283 global_init(void)
 284 {
 285   static uns initialized = 0;
 286   if (initialized++)
 287     return;
 288   sections.flags |= SEC_FLAG_UNKNOWN;
 289   sections.size = 0;                    // size of allocated array used to be stored here
 290   cf_init_section("top-level", &sections, NULL, 0);
 291 }
 292
 293 static int
 294 commit_section(byte *name, struct cf_section *sec, void *ptr, uns commit_all)
 295 {
 296   struct cf_item *ci;
 297   for (ci=sec->cfg; ci->cls; ci++)
 298     if (ci->cls == CC_SECTION) {
 299       if (commit_section(ci->name, ci->u.sec, ptr + (addr_int_t) ci->ptr, commit_all)) {
 300         log(L_ERROR, "It happened in section %s", ci->name);
 301         return 1;
 302       }
 303     } else if (ci->cls == CC_LIST) {
 304       struct cnode *n;
 305       uns idx = 0;
 306       CLIST_WALK(n, * (clist*) (ptr + (addr_int_t) ci->ptr))
 307         if (idx++, commit_section(ci->name, ci->u.sec, n, commit_all)) {
 308           log(L_ERROR, "It happened in node #%d of list %s", idx, ci->name);
 309           return 1;
 310         }
 311     }
 312   if (sec->commit) {
 313     /* We have to process the whole tree of sections even if just a few changes
 314      * have been made, because there are dependencies between commit-hooks and
 315      * hence we need to call them in a fixed order.  */
 316 #define ARY_LT_X(ary,i,x) ary[i].sec < x.sec || ary[i].sec == x.sec && ary[i].ptr < x.ptr
 317     struct dirty_section comp = { sec, ptr };
 318     uns pos = BIN_SEARCH_FIRST_GE_CMP(dirty.ptr, dirties, comp, ARY_LT_X);
 319
 320     if (commit_all
 321         || (pos < dirties && dirty.ptr[pos].sec == sec && dirty.ptr[pos].ptr == ptr)) {
 322       byte *msg = sec->commit(ptr);
 323       if (msg) {
 324         log(L_ERROR, "Cannot commit section %s: %s", name, msg);
 325         return 1;
 326       }
 327     }
 328   }
 329   return 0;
 330 }
 331
 332 static struct cf_item *
 333 find_item(struct cf_section *curr_sec, byte *name, byte **msg, void **ptr)
 334 {
 335   *msg = NULL;
 336   if (name[0] == '^')                           // absolute name instead of relative
 337     name++, curr_sec = &sections, *ptr = NULL;
 338   if (!curr_sec)                                // don't even search in an unknown section
 339     return NULL;
 340   while (1)
 341   {
 342     if (curr_sec != &sections)
 343       add_dirty(curr_sec, *ptr);
 344     byte *c = strchr(name, '.');
 345     if (c)
 346       *c++ = 0;
 347     struct cf_item *ci = find_subitem(curr_sec, name);
 348     if (!ci->cls)
 349     {
 350       if (!(curr_sec->flags & SEC_FLAG_UNKNOWN))        // ignore silently unknown top-level sections and unknown attributes in flagged sections
 351         *msg = cf_printf("Unknown item %s", name);
 352       return NULL;
 353     }
 354     *ptr += (addr_int_t) ci->ptr;
 355     if (!c)
 356       return ci;
 357     if (ci->cls != CC_SECTION)
 358     {
 359       *msg = cf_printf("Item %s is not a section", name);
 360       return NULL;
 361     }
 362     curr_sec = ci->u.sec;
 363     name = c;
 364   }
 365 }
 366
 367 byte *
 368 cf_find_item(byte *name, struct cf_item *item)
 369 {
 370   byte *msg;
 371   void *ptr;
 372   struct cf_item *ci = find_item(&sections, name, &msg, &ptr);
 373   if (msg)
 374     return msg;
 375   *item = *ci;
 376   item->ptr = ptr;
 377   return NULL;
 378 }
 379
 380 /* Safe loading and reloading */
 381
 382 static int load_file(byte *file);
 383 static int load_string(byte *string);
 384
 385 int
 386 cf_reload(byte *file)
 387 {
 388   journal_swap();
 389   struct journal_item *oldj = journal_new_transaction(1);
 390   uns ec = everything_committed;
 391   everything_committed = 0;
 392   int err = load_file(file);
 393   if (!err)
 394   {
 395     for (struct old_pools *p=pools; p; p=pools)
 396     {
 397       pools = p->prev;
 398       mp_delete(p->pool);
 399     }
 400     journal_commit_transaction(1, NULL);
 401   }
 402   else
 403   {
 404     everything_committed = ec;
 405     journal_rollback_transaction(1, oldj);
 406     journal_swap();
 407   }
 408   return err;
 409 }
 410
 411 int
 412 cf_load(byte *file)
 413 {
 414   struct journal_item *oldj = journal_new_transaction(1);
 415   int err = load_file(file);
 416   if (!err)
 417     journal_commit_transaction(1, oldj);
 418   else
 419     journal_rollback_transaction(1, oldj);
 420   return err;
 421 }
 422
 423 int
 424 cf_set(byte *string)
 425 {
 426   struct journal_item *oldj = journal_new_transaction(0);
 427   int err = load_string(string);
 428   if (!err)
 429     journal_commit_transaction(0, oldj);
 430   else
 431     journal_rollback_transaction(0, oldj);
 432   return err;
 433 }
 434
 435 /* Parsers for standard types */
 436
 437 struct unit {
 438   uns name;                     // one-letter name of the unit
 439   uns num, den;                 // fraction
 440 };
 441
 442 static const struct unit units[] = {
 443   { 'd', 86400, 1 },
 444   { 'h', 3600, 1 },
 445   { 'k', 1000, 1 },
 446   { 'm', 1000000, 1 },
 447   { 'g', 1000000000, 1 },
 448   { 'K', 1024, 1 },
 449   { 'M', 1048576, 1 },
 450   { 'G', 1073741824, 1 },
 451   { '%', 1, 100 },
 452   { 0, 0, 0 }
 453 };
 454
 455 static const struct unit *
 456 lookup_unit(byte *value, byte *end, byte **msg)
 457 {
 458   if (end && *end) {
 459     if (end == value || end[1] || *end >= '0' && *end <= '9')
 460       *msg = "Invalid number";
 461     else {
 462       for (const struct unit *u=units; u->name; u++)
 463         if (u->name == *end)
 464           return u;
 465       *msg = "Invalid unit";
 466     }
 467   }
 468   return NULL;
 469 }
 470
 471 static char cf_rngerr[] = "Number out of range";
 472
 473 byte *
 474 cf_parse_int(byte *str, int *ptr)
 475 {
 476   byte *msg = NULL;
 477   if (!*str)
 478     msg = "Missing number";
 479   else {
 480     const struct unit *u;
 481     char *end;
 482     errno = 0;
 483     uns x = strtoul(str, &end, 0);
 484     if (errno == ERANGE)
 485       msg = cf_rngerr;
 486     else if (u = lookup_unit(str, end, &msg)) {
 487       u64 y = (u64)x * u->num;
 488       if (y % u->den)
 489         msg = "Number is not an integer";
 490       else {
 491         y /= u->den;
 492         if (y > 0xffffffff)
 493           msg = cf_rngerr;
 494         *ptr = y;
 495       }
 496     } else
 497       *ptr = x;
 498   }
 499   return msg;
 500 }
 501
 502 byte *
 503 cf_parse_u64(byte *str, u64 *ptr)
 504 {
 505   byte *msg = NULL;
 506   if (!*str)
 507     msg = "Missing number";
 508   else {
 509     const struct unit *u;
 510     char *end;
 511     errno = 0;
 512     u64 x = strtoull(str, &end, 0);
 513     if (errno == ERANGE)
 514       msg = cf_rngerr;
 515     else if (u = lookup_unit(str, end, &msg)) {
 516       if (x > ~(u64)0 / u->num)
 517         msg = "Number out of range";
 518       else {
 519         x *= u->num;
 520         if (x % u->den)
 521           msg = "Number is not an integer";
 522         else
 523           *ptr = x / u->den;
 524       }
 525     } else
 526       *ptr = x;
 527   }
 528   return msg;
 529 }
 530
 531 byte *
 532 cf_parse_double(byte *str, double *ptr)
 533 {
 534   byte *msg = NULL;
 535   if (!*str)
 536     msg = "Missing number";
 537   else {
 538     const struct unit *u;
 539     double x;
 540     uns read_chars;
 541     if (sscanf(str, "%lf%n", &x, &read_chars) != 1)
 542       msg = "Invalid number";
 543     else if (u = lookup_unit(str, str + read_chars, &msg))
 544       *ptr = x * u->num / u->den;
 545     else
 546       *ptr = x;
 547   }
 548   return msg;
 549 }
 550
 551 byte *
 552 cf_parse_ip(byte *p, u32 *varp)
 553 {
 554   if (!*p)
 555     return "Missing IP address";
 556   uns x = 0;
 557   char *p2;
 558   if (*p == '0' && p[1] | 32 == 'X' && Cxdigit(p[2])) {
 559     errno = 0;
 560     x = strtoul(p, &p2, 16);
 561     if (errno == ERANGE || x > 0xffffffff)
 562       goto error;
 563     p = p2;
 564   }
 565   else
 566     for (uns i = 0; i < 4; i++) {
 567       if (i) {
 568         if (*p++ != '.')
 569           goto error;
 570       }
 571       if (!Cdigit(*p))
 572         goto error;
 573       errno = 0;
 574       uns y = strtoul(p, &p2, 10);
 575       if (errno == ERANGE || p2 == (char*) p || y > 255)
 576         goto error;
 577       p = p2;
 578       x = (x << 8) + y;
 579     }
 580   *varp = x;
 581   return *p ? "Trailing characters" : NULL;
 582 error:
 583   return "Invalid IP address";
 584 }
 585
 586 static byte *
 587 cf_parse_string(byte *str, byte **ptr)
 588 {
 589   *ptr = cf_strdup(str);
 590   return NULL;
 591 }
 592
 593 static byte *
 594 cf_parse_lookup(byte *str, int *ptr, char **t)
 595 {
 596   char **n = t;
 597   uns total_len = 0;
 598   while (*n && strcasecmp(*n, str)) {
 599     total_len += strlen(*n) + 2;
 600     n++;
 601   }
 602   if (*n) {
 603     *ptr = n - t;
 604     return NULL;
 605   }
 606   byte *err = cf_malloc(total_len + strlen(str) + 60), *c = err;
 607   c += sprintf(err, "Invalid value %s, possible values are: ", str);
 608   for (n=t; *n; n++)
 609     c+= sprintf(c, "%s, ", *n);
 610   *ptr = -1;
 611   return err;
 612 }
 613
 614 /* Register size of and parser for each basic type */
 615
 616 typedef byte *cf_basic_parser(byte *str, void *ptr);
 617 static struct {
 618   uns size;
 619   void *parser;
 620 } parsers[] = {
 621   { sizeof(int), cf_parse_int },
 622   { sizeof(u64), cf_parse_u64 },
 623   { sizeof(double), cf_parse_double },
 624   { sizeof(u32), cf_parse_ip },
 625   { sizeof(byte*), cf_parse_string },
 626   { sizeof(int), NULL }                         // lookups are parsed extra
 627 };
 628
 629 static byte *
 630 cf_parse_ary(uns number, byte **pars, void *ptr, enum cf_type type, union cf_union *u)
 631 {
 632   for (uns i=0; i<number; i++)
 633   {
 634     byte *msg;
 635     if (type < CT_LOOKUP)
 636       msg = ((cf_basic_parser*) parsers[type].parser) (pars[i], ptr + i * parsers[type].size);
 637     else if (type == CT_LOOKUP)
 638       msg = cf_parse_lookup(pars[i], ptr + i * sizeof(int), u->lookup);
 639     else
 640       ASSERT(0);
 641     if (msg)
 642       return cf_printf("Cannot parse item %d: %s", i+1, msg);
 643   }
 644   return NULL;
 645 }
 646
 647 /* Interpreter */
 648
 649 #define T(x) #x,
 650 static byte *op_names[] = { CF_OPERATIONS };
 651 #undef T
 652
 653 #define OP_MASK 0xff            // only get the operation
 654 #define OP_OPEN 0x100           // here we only get an opening brace instead of parameters
 655 #define OP_1ST 0x200            // in the 1st phase selectors are recorded into the mask
 656 #define OP_2ND 0x400            // in the 2nd phase real data are entered
 657
 658 static byte *
 659 interpret_set_dynamic(struct cf_item *item, int number, byte **pars, void **ptr)
 660 {
 661   enum cf_type type = item->type;
 662   cf_journal_block(ptr, sizeof(void*));
 663   // boundary checks done by the caller
 664   *ptr = cf_malloc((number+1) * parsers[type].size) + parsers[type].size;
 665   * (uns*) (*ptr - parsers[type].size) = number;
 666   return cf_parse_ary(number, pars, *ptr, type, &item->u);
 667 }
 668
 669 static byte *
 670 interpret_add_dynamic(struct cf_item *item, int number, byte **pars, int *processed, void **ptr, enum cf_operation op)
 671 {
 672   enum cf_type type = item->type;
 673   void *old_p = *ptr;
 674   int old_nr = * (int*) (old_p - parsers[type].size);
 675   int taken = MIN(number, item->number-old_nr);
 676   *processed = taken;
 677   // stretch the dynamic array
 678   void *new_p = cf_malloc((old_nr + taken + 1) * parsers[type].size) + parsers[type].size;
 679   * (uns*) (new_p - parsers[type].size) = old_nr + taken;
 680   cf_journal_block(ptr, sizeof(void*));
 681   *ptr = new_p;
 682   if (op == OP_APPEND) {
 683     memcpy(new_p, old_p, old_nr * parsers[type].size);
 684     return cf_parse_ary(taken, pars, new_p + old_nr * parsers[type].size, type, &item->u);
 685   } else if (op == OP_PREPEND) {
 686     memcpy(new_p + taken * parsers[type].size, old_p, old_nr * parsers[type].size);
 687     return cf_parse_ary(taken, pars, new_p, type, &item->u);
 688   } else
 689     return cf_printf("Dynamic arrays do not support operation %s", op_names[op]);
 690 }
 691
 692 static byte *interpret_set_item(struct cf_item *item, int number, byte **pars, int *processed, void *ptr, uns allow_dynamic);
 693
 694 static byte *
 695 interpret_section(struct cf_section *sec, int number, byte **pars, int *processed, void *ptr, uns allow_dynamic)
 696 {
 697   add_dirty(sec, ptr);
 698   *processed = 0;
 699   for (struct cf_item *ci=sec->cfg; ci->cls; ci++)
 700   {
 701     int taken;
 702     byte *msg = interpret_set_item(ci, number, pars, &taken, ptr + (addr_int_t) ci->ptr, allow_dynamic && !ci[1].cls);
 703     if (msg)
 704       return cf_printf("Item %s: %s", ci->name, msg);
 705     *processed += taken;
 706     number -= taken;
 707     pars += taken;
 708     if (!number)                // stop parsing, because many parsers would otherwise complain that number==0
 709       break;
 710   }
 711   return NULL;
 712 }
 713
 714 static void
 715 add_to_list(struct cnode *where, struct cnode *new_node, enum cf_operation op)
 716 {
 717   switch (op)
 718   {
 719     case OP_EDIT:               // edition has been done in-place
 720       break;
 721     case OP_REMOVE:
 722       cf_journal_block(&where->prev->next, sizeof(void*));
 723       cf_journal_block(&where->next->prev, sizeof(void*));
 724       clist_remove(where);
 725       break;
 726     case OP_AFTER:              // implementation dependend (prepend_head = after(list)), and where==list, see clists.h:74
 727     case OP_PREPEND:
 728       cf_journal_block(&where->next->prev, sizeof(void*));
 729       cf_journal_block(&where->next, sizeof(void*));
 730       clist_insert_after(new_node, where);
 731       break;
 732     case OP_BEFORE:             // implementation dependend (append_tail = before(list))
 733     case OP_APPEND:
 734     case OP_SET:
 735       cf_journal_block(&where->prev->next, sizeof(void*));
 736       cf_journal_block(&where->prev, sizeof(void*));
 737       clist_insert_before(new_node, where);
 738       break;
 739     default:
 740       ASSERT(0);
 741   }
 742 }
 743
 744 static byte *
 745 interpret_add_list(struct cf_item *item, int number, byte **pars, int *processed, void *ptr, enum cf_operation op)
 746 {
 747   if (op >= OP_REMOVE)
 748     return cf_printf("You have to open a block for operation %s", op_names[op]);
 749   if (!number)
 750     return "Nothing to add to the list";
 751   struct cf_section *sec = item->u.sec;
 752   *processed = 0;
 753   while (number > 0)
 754   {
 755     void *node = cf_malloc(sec->size);
 756     cf_init_section(item->name, sec, node, 1);
 757     add_to_list(ptr, node, op);
 758     int taken;
 759     /* If the node contains any dynamic attribute at the end, we suppress
 760      * auto-repetition here and pass the flag inside instead.  */
 761     TRY( interpret_section(sec, number, pars, &taken, node, sec->flags & SEC_FLAG_DYNAMIC) );
 762     *processed += taken;
 763     number -= taken;
 764     pars += taken;
 765     if (sec->flags & SEC_FLAG_DYNAMIC)
 766       break;
 767   }
 768   return NULL;
 769 }
 770
 771 static byte *
 772 interpret_set_item(struct cf_item *item, int number, byte **pars, int *processed, void *ptr, uns allow_dynamic)
 773 {
 774   int taken;
 775   switch (item->cls)
 776   {
 777     case CC_STATIC:
 778       if (!number)
 779         return "Missing value";
 780       taken = MIN(number, item->number);
 781       *processed = taken;
 782       cf_journal_block(ptr, taken * parsers[item->type].size);
 783       return cf_parse_ary(taken, pars, ptr, item->type, &item->u);
 784     case CC_DYNAMIC:
 785       if (!allow_dynamic)
 786         return "Dynamic array cannot be used here";
 787       taken = MIN(number, item->number);
 788       *processed = taken;
 789       return interpret_set_dynamic(item, taken, pars, ptr);
 790     case CC_PARSER:
 791       if (item->number < 0 && !allow_dynamic)
 792         return "Parsers with variable number of parameters cannot be used here";
 793       if (item->number > 0 && number < item->number)
 794         return "Not enough parameters available for the parser";
 795       taken = MIN(number, ABS(item->number));
 796       *processed = taken;
 797       for (int i=0; i<taken; i++)
 798         pars[i] = cf_strdup(pars[i]);
 799       return item->u.par(taken, pars, ptr);
 800     case CC_SECTION:
 801       return interpret_section(item->u.sec, number, pars, processed, ptr, allow_dynamic);
 802     case CC_LIST:
 803       if (!allow_dynamic)
 804         return "Lists cannot be used here";
 805       return interpret_add_list(item, number, pars, processed, ptr, OP_SET);
 806     default:
 807       ASSERT(0);
 808   }
 809 }
 810
 811 static byte *
 812 interpret_clear(struct cf_item *item, void *ptr)
 813 {
 814   if (item->cls == CC_LIST) {
 815     cf_journal_block(ptr, sizeof(struct clist));
 816     clist_init(ptr);
 817   } else if (item->cls == CC_DYNAMIC) {
 818     cf_journal_block(ptr, sizeof(void *));
 819     * (void**) ptr = NULL;
 820   } else
 821     return "The item is not a list or a dynamic array";
 822   return NULL;
 823 }
 824
 825 static int
 826 cmp_items(void *i1, void *i2, struct cf_item *item)
 827 {
 828   ASSERT(item->cls == CC_STATIC);
 829   i1 += (addr_int_t) item->ptr;
 830   i2 += (addr_int_t) item->ptr;
 831   if (item->type == CT_STRING)
 832     return strcmp(* (byte**) i1, * (byte**) i2);
 833   else                          // all numeric types
 834     return memcmp(i1, i2, parsers[item->type].size);
 835 }
 836
 837 static void *
 838 find_list_node(struct clist *list, void *query, struct cf_section *sec, u32 mask)
 839 {
 840   struct cnode *n;
 841   CLIST_WALK(n, *list)
 842   {
 843     uns found = 1;
 844     for (uns i=0; i<32; i++)
 845       if (mask & (1<<i))
 846         if (cmp_items(n, query, sec->cfg+i))
 847         {
 848           found = 0;
 849           break;
 850         }
 851     if (found)
 852       return n;
 853   }
 854   return NULL;
 855 }
 856
 857 static byte *
 858 record_selector(struct cf_item *item, struct cf_section *sec, u32 *mask)
 859 {
 860   uns nr = sec->flags & SEC_FLAG_NUMBER;
 861   if (item >= sec->cfg && item < sec->cfg + nr) // setting an attribute relative to this section
 862   {
 863     uns i = item - sec->cfg;
 864     if (i >= 32)
 865       return "Cannot select list nodes by this attribute";
 866     if (sec->cfg[i].cls != CC_STATIC)
 867       return "Selection can only be done based on basic attributes";
 868     *mask |= 1 << i;
 869   }
 870   return NULL;
 871 }
 872
 873 #define MAX_STACK_SIZE  100
 874 static struct item_stack {
 875   struct cf_section *sec;       // nested section
 876   void *base_ptr;               // because original pointers are often relative
 877   enum cf_operation op;         // it is performed when a closing brace is encountered
 878   void *list;                   // list the operations should be done on
 879   u32 mask;                     // bit array of selectors searching in a list
 880   struct cf_item *item;         // cf_item of the list
 881 } stack[MAX_STACK_SIZE];
 882 static uns level;
 883
 884 static byte *
 885 opening_brace(struct cf_item *item, void *ptr, enum cf_operation op)
 886 {
 887   if (level >= MAX_STACK_SIZE-1)
 888     return "Too many nested sections";
 889   stack[++level] = (struct item_stack) {
 890     .sec = NULL,
 891     .base_ptr = NULL,
 892     .op = op & OP_MASK,
 893     .list = NULL,
 894     .mask = 0,
 895     .item = NULL,
 896   };
 897   if (!item)                    // unknown is ignored; we just need to trace recursion
 898     return NULL;
 899   stack[level].sec = item->u.sec;
 900   if (item->cls == CC_SECTION)
 901   {
 902     stack[level].base_ptr = ptr;
 903     stack[level].op = OP_EDIT | OP_2ND; // this list operation does nothing
 904   }
 905   else if (item->cls == CC_LIST)
 906   {
 907     stack[level].base_ptr = cf_malloc(item->u.sec->size);
 908     cf_init_section(item->name, item->u.sec, stack[level].base_ptr, 1);
 909     stack[level].list = ptr;
 910     stack[level].item = item;
 911     if ((op & OP_MASK) < OP_REMOVE) {
 912       add_to_list(ptr, stack[level].base_ptr, op & OP_MASK);
 913       stack[level].op |= OP_2ND;
 914     } else
 915       stack[level].op |= OP_1ST;
 916   }
 917   else
 918     return "Opening brace can only be used on sections and lists";
 919   return NULL;
 920 }
 921
 922 static byte *
 923 closing_brace(struct item_stack *st, enum cf_operation op, int number, byte **pars)
 924 {
 925   if (st->op == OP_CLOSE)       // top-level
 926     return "Unmatched } parenthesis";
 927   if (!st->sec) {               // dummy run on unknown section
 928     if (!(op & OP_OPEN))
 929       level--;
 930     return NULL;
 931   }
 932   enum cf_operation pure_op = st->op & OP_MASK;
 933   if (st->op & OP_1ST)
 934   {
 935     st->list = find_list_node(st->list, st->base_ptr, st->sec, st->mask);
 936     if (!st->list)
 937       return "Cannot find a node matching the query";
 938     if (pure_op != OP_REMOVE)
 939     {
 940       if (pure_op == OP_EDIT)
 941         st->base_ptr = st->list;
 942       else if (pure_op == OP_AFTER || pure_op == OP_BEFORE)
 943         cf_init_section(st->item->name, st->sec, st->base_ptr, 1);
 944       else
 945         ASSERT(0);
 946       if (op & OP_OPEN) {       // stay at the same recursion level
 947         st->op = (st->op | OP_2ND) & ~OP_1ST;
 948         add_to_list(st->list, st->base_ptr, pure_op);
 949         return NULL;
 950       }
 951       int taken;                // parse parameters on 1 line immediately
 952       TRY( interpret_section(st->sec, number, pars, &taken, st->base_ptr, 1) );
 953       number -= taken;
 954       pars += taken;
 955       // and fall-thru to the 2nd phase
 956     }
 957     add_to_list(st->list, st->base_ptr, pure_op);
 958   }
 959   level--;
 960   if (number)
 961     return "No parameters expected after the }";
 962   else if (op & OP_OPEN)
 963     return "No { is expected";
 964   else
 965     return NULL;
 966 }
 967
 968 static byte *
 969 interpret_line(byte *name, enum cf_operation op, int number, byte **pars)
 970 {
 971   byte *msg;
 972   if ((op & OP_MASK) == OP_CLOSE)
 973     return closing_brace(stack+level, op, number, pars);
 974   void *ptr = stack[level].base_ptr;
 975   struct cf_item *item = find_item(stack[level].sec, name, &msg, &ptr);
 976   if (msg)
 977     return msg;
 978   if (stack[level].op & OP_1ST)
 979     TRY( record_selector(item, stack[level].sec, &stack[level].mask) );
 980   if (op & OP_OPEN) {           // the operation will be performed after the closing brace
 981     if (number)
 982       return "Cannot open a block after a parameter has been passed on a line";
 983     return opening_brace(item, ptr, op);
 984   }
 985   if (!item)                    // ignored item in an unknown section
 986     return NULL;
 987   op &= OP_MASK;
 988
 989   int taken;                    // process as many parameters as possible
 990   if (op == OP_CLEAR)
 991     taken = 0, msg = interpret_clear(item, ptr);
 992   else if (op == OP_SET)
 993     msg = interpret_set_item(item, number, pars, &taken, ptr, 1);
 994   else if (item->cls == CC_DYNAMIC)
 995     msg = interpret_add_dynamic(item, number, pars, &taken, ptr, op);
 996   else if (item->cls == CC_LIST)
 997     msg = interpret_add_list(item, number, pars, &taken, ptr, op);
 998   else
 999     return cf_printf("Operation %s not supported on attribute %s", op_names[op], name);
1000   if (msg)
1001     return msg;
1002   if (taken < number)
1003     return cf_printf("Too many parameters: %d>%d", number, taken);
1004
1005   return NULL;
1006 }
1007
1008 byte *
1009 cf_write_item(struct cf_item *item, enum cf_operation op, int number, byte **pars)
1010 {
1011   byte *msg;
1012   int taken;
1013   switch (op) {
1014     case OP_SET:
1015       msg = interpret_set_item(item, number, pars, &taken, item->ptr, 1);
1016       break;
1017     case OP_CLEAR:
1018       taken = 0;
1019       msg = interpret_clear(item, item->ptr);
1020       break;
1021     case OP_APPEND:
1022     case OP_PREPEND:
1023       if (item->cls == CC_DYNAMIC)
1024         msg = interpret_add_dynamic(item, number, pars, &taken, item->ptr, op);
1025       else if (item->cls == CC_LIST)
1026         msg = interpret_add_list(item, number, pars, &taken, item->ptr, op);
1027       else
1028         return "The attribute class does not support append/prepend";
1029       break;
1030     default:
1031       return "Unsupported operation";
1032   }
1033   if (msg)
1034     return msg;
1035   if (taken < number)
1036     return "Too many parameters";
1037   return NULL;
1038 }
1039
1040 static void
1041 init_stack(void)
1042 {
1043   global_init();
1044   level = 0;
1045   stack[0] = (struct item_stack) {
1046     .sec = &sections,
1047     .base_ptr = NULL,
1048     .op = OP_CLOSE,
1049     .list = NULL,
1050     .mask = 0,
1051     .item = NULL
1052   };
1053 }
1054
1055 static int
1056 done_stack(void)
1057 {
1058   if (level > 0) {
1059     log(L_ERROR, "Unterminated block");
1060     return 1;
1061   }
1062   sort_dirty();
1063   if (commit_section("top-level", &sections, NULL, !everything_committed))
1064     return 1;
1065   everything_committed = 1;
1066   dirties = 0;
1067   return 0;
1068 }
1069
1070 /* Text file parser */
1071
1072 static byte *name_parse_fb;
1073 static struct fastbuf *parse_fb;
1074 static uns line_num;
1075
1076 #define MAX_LINE        4096
1077 static byte line_buf[MAX_LINE];
1078 static byte *line = line_buf;
1079
1080 #include "lib/bbuf.h"
1081 static bb_t copy_buf;
1082 static uns copied;
1083
1084 #define GBUF_TYPE       uns
1085 #define GBUF_PREFIX(x)  split_##x
1086 #include "lib/gbuf.h"
1087 static split_t word_buf;
1088 static uns words;
1089 static uns ends_by_brace;               // the line is ended by "{"
1090
1091 static int
1092 get_line(void)
1093 {
1094   if (!bgets(parse_fb, line_buf, MAX_LINE))
1095     return 0;
1096   line_num++;
1097   line = line_buf;
1098   while (Cblank(*line))
1099     line++;
1100   return 1;
1101 }
1102
1103 static void
1104 append(byte *start, byte *end)
1105 {
1106   uns len = end - start;
1107   bb_grow(&copy_buf, copied + len + 1);
1108   memcpy(copy_buf.ptr + copied, start, len);
1109   copied += len + 1;
1110   copy_buf.ptr[copied-1] = 0;
1111 }
1112
1113 #define CONTROL_CHAR(x) (x == '{' || x == '}' || x == ';')
1114   // these characters separate words like blanks
1115
1116 static byte *
1117 get_word(uns is_command_name)
1118 {
1119   if (*line == '\'') {
1120     line++;
1121     while (1) {
1122       byte *start = line;
1123       while (*line && *line != '\'')
1124         line++;
1125       append(start, line);
1126       if (*line)
1127         break;
1128       copy_buf.ptr[copied-1] = '\n';
1129       if (!get_line())
1130         return "Unterminated apostrophe word at the end";
1131     }
1132     line++;
1133
1134   } else if (*line == '"') {
1135     line++;
1136     uns start_copy = copied;
1137     while (1) {
1138       byte *start = line;
1139       uns escape = 0;
1140       while (*line) {
1141         if (*line == '"' && !escape)
1142           break;
1143         else if (*line == '\\')
1144           escape ^= 1;
1145         else
1146           escape = 0;
1147         line++;
1148       }
1149       append(start, line);
1150       if (*line)
1151         break;
1152       if (!escape)
1153         copy_buf.ptr[copied-1] = '\n';
1154       else // merge two lines
1155         copied -= 2;
1156       if (!get_line())
1157         return "Unterminated quoted word at the end";
1158     }
1159     line++;
1160
1161     byte *tmp = stk_str_unesc(copy_buf.ptr + start_copy);
1162     uns l = strlen(tmp);
1163     bb_grow(&copy_buf, start_copy + l + 1);
1164     strcpy(copy_buf.ptr + start_copy, tmp);
1165     copied = start_copy + l + 1;
1166
1167   } else {
1168     // promised that *line is non-null and non-blank
1169     byte *start = line;
1170     while (*line && !Cblank(*line) && !CONTROL_CHAR(*line)
1171         && (*line != '=' || !is_command_name))
1172       line++;
1173     if (*line == '=') {                         // nice for setting from a command-line
1174       if (line == start)
1175         return "Assignment without a variable";
1176       *line = ' ';
1177     }
1178     if (line == start)                          // already the first char is control
1179       line++;
1180     append(start, line);
1181   }
1182   while (Cblank(*line))
1183     line++;
1184   return NULL;
1185 }
1186
1187 static byte *
1188 get_token(uns is_command_name, byte **msg)
1189 {
1190   *msg = NULL;
1191   while (1) {
1192     if (!*line || *line == '#') {
1193       if (!is_command_name || !get_line())
1194         return NULL;
1195     } else if (*line == ';') {
1196       *msg = get_word(0);
1197       if (!is_command_name || *msg)
1198         return NULL;
1199     } else if (*line == '\\' && !line[1]) {
1200       if (!get_line()) {
1201         *msg = "Last line ends by a backslash";
1202         return NULL;
1203       }
1204       if (!*line || *line == '#')
1205         log(L_WARN, "The line %s:%d following a backslash is empty", name_parse_fb, line_num);
1206     } else {
1207       split_grow(&word_buf, words+1);
1208       uns start = copied;
1209       word_buf.ptr[words++] = copied;
1210       *msg = get_word(is_command_name);
1211       return *msg ? NULL : copy_buf.ptr + start;
1212     }
1213   }
1214 }
1215
1216 static byte *
1217 split_command(void)
1218 {
1219   words = copied = ends_by_brace = 0;
1220   byte *msg, *start_word;
1221   if (!(start_word = get_token(1, &msg)))
1222     return msg;
1223   if (*start_word == '{')                       // only one opening brace
1224     return "Unexpected opening brace";
1225   while (*line != '}')                          // stays for the next time
1226   {
1227     if (!(start_word = get_token(0, &msg)))
1228       return msg;
1229     if (*start_word == '{') {
1230       words--;                                  // discard the brace
1231       ends_by_brace = 1;
1232       break;
1233     }
1234   }
1235   return NULL;
1236 }
1237
1238 /* Parsing multiple files */
1239
1240 static byte *
1241 parse_fastbuf(byte *name_fb, struct fastbuf *fb, uns depth)
1242 {
1243   byte *msg;
1244   name_parse_fb = name_fb;
1245   parse_fb = fb;
1246   line_num = 0;
1247   line = line_buf;
1248   *line = 0;
1249   while (1)
1250   {
1251     msg = split_command();
1252     if (msg)
1253       goto error;
1254     if (!words)
1255       return NULL;
1256     byte *name = copy_buf.ptr + word_buf.ptr[0];
1257     byte *pars[words-1];
1258     for (uns i=1; i<words; i++)
1259       pars[i-1] = copy_buf.ptr + word_buf.ptr[i];
1260     if (!strcasecmp(name, "include"))
1261     {
1262       if (words != 2)
1263         msg = "Expecting one filename";
1264       else if (depth > 8)
1265         msg = "Too many nested files";
1266       else if (*line && *line != '#')           // because the contents of line_buf is not re-entrant and will be cleared
1267         msg = "The input command must be the last one on a line";
1268       if (msg)
1269         goto error;
1270       struct fastbuf *new_fb = bopen_try(pars[0], O_RDONLY, 1<<14);
1271       if (!new_fb) {
1272         msg = cf_printf("Cannot open file %s: %m", pars[0]);
1273         goto error;
1274       }
1275       uns ll = line_num;
1276       msg = parse_fastbuf(pars[0], new_fb, depth+1);
1277       bclose(new_fb);
1278       if (msg)
1279         goto error;
1280       line_num = ll;
1281       parse_fb = fb;
1282     }
1283     enum cf_operation op;
1284     byte *c = strchr(name, ':');
1285     if (!c)
1286       op = strcmp(name, "}") ? OP_SET : OP_CLOSE;
1287     else {
1288       *c++ = 0;
1289       switch (Clocase(*c)) {
1290         case 's': op = OP_SET; break;
1291         case 'c': op = OP_CLEAR; break;
1292         case 'a': op = Clocase(c[1]) == 'p' ? OP_APPEND : OP_AFTER; break;
1293         case 'p': op = OP_PREPEND; break;
1294         case 'r': op = OP_REMOVE; break;
1295         case 'e': op = OP_EDIT; break;
1296         case 'b': op = OP_BEFORE; break;
1297         default: op = OP_SET; break;
1298       }
1299       if (strcasecmp(c, op_names[op])) {
1300         msg = cf_printf("Unknown operation %s", c);
1301         goto error;
1302       }
1303     }
1304     if (ends_by_brace)
1305       op |= OP_OPEN;
1306     msg = interpret_line(name, op, words-1, pars);
1307     if (msg)
1308       goto error;
1309   }
1310 error:
1311   log(L_ERROR, "File %s, line %d: %s", name_fb, line_num, msg);
1312   return "included from here";
1313 }
1314
1315 #undef DEFAULT_CONFIG                   /* FIXME */
1316 #define DEFAULT_CONFIG "cf/sherlock2"
1317
1318 #ifndef DEFAULT_CONFIG
1319 #define DEFAULT_CONFIG NULL
1320 #endif
1321 byte *cf_def_file = DEFAULT_CONFIG;
1322
1323 static int
1324 load_file(byte *file)
1325 {
1326   init_stack();
1327   struct fastbuf *fb = bopen_try(file, O_RDONLY, 1<<14);
1328   if (!fb) {
1329     log(L_ERROR, "Cannot open %s: %m", file);
1330     return 1;
1331   }
1332   byte *msg = parse_fastbuf(file, fb, 0);
1333   bclose(fb);
1334   int err = !!msg || done_stack();
1335   if (!err)
1336     cf_def_file = NULL;
1337   return err;
1338 }
1339
1340 static int
1341 load_string(byte *string)
1342 {
1343   init_stack();
1344   struct fastbuf fb;
1345   fbbuf_init_read(&fb, string, strlen(string), 0);
1346   byte *msg = parse_fastbuf("memory string", &fb, 0);
1347   return !!msg || done_stack();
1348 }
1349
1350 /* Command-line parser */
1351
1352 static void
1353 load_default(void)
1354 {
1355   if (cf_def_file)
1356     if (cf_load(cf_def_file))
1357       die("Cannot load default config %s", cf_def_file);
1358 }
1359
1360 int
1361 cf_get_opt(int argc, char * const argv[], const char *short_opts, const struct option *long_opts, int *long_index)
1362 {
1363   static int other_options = 0;
1364   while (1) {
1365     int res = getopt_long (argc, argv, short_opts, long_opts, long_index);
1366     if (res == 'S' || res == 'C')
1367     {
1368       if (other_options)
1369         die("The -S and -C options must precede all other arguments");
1370       if (res == 'S') {
1371         load_default();
1372         if (cf_set(optarg))
1373           die("Cannot set %s", optarg);
1374       } else {
1375         if (cf_load(optarg))
1376           die("Cannot load config file %s", optarg);
1377       }
1378     } else {
1379       /* unhandled option or end of options */
1380       if (res != ':' && res != '?')
1381         load_default();
1382       other_options++;
1383       return res;
1384     }
1385   }
1386 }
1387
1388 /* Debug dumping */
1389
1390 static void
1391 spaces(struct fastbuf *fb, uns nr)
1392 {
1393   for (uns i=0; i<nr; i++)
1394     bputs(fb, "  ");
1395 }
1396
1397 static void
1398 dump_basic(struct fastbuf *fb, void *ptr, enum cf_type type, union cf_union *u)
1399 {
1400   switch (type) {
1401     case CT_INT:        bprintf(fb, "%d ", *(uns*)ptr); break;
1402     case CT_U64:        bprintf(fb, "%llu ", *(u64*)ptr); break;
1403     case CT_DOUBLE:     bprintf(fb, "%lg ", *(double*)ptr); break;
1404     case CT_IP:         bprintf(fb, "%08x ", *(uns*)ptr); break;
1405     case CT_STRING:     bprintf(fb, "'%s' ", *(byte**)ptr); break;
1406     case CT_LOOKUP:     bprintf(fb, "%s ", *(int*)ptr >= 0 ? u->lookup[ *(int*)ptr ] : "???"); break;
1407   }
1408 }
1409
1410 static void dump_section(struct fastbuf *fb, struct cf_section *sec, int level, void *ptr);
1411
1412 static void
1413 dump_item(struct fastbuf *fb, struct cf_item *item, int level, void *ptr)
1414 {
1415   ptr += (addr_int_t) item->ptr;
1416   enum cf_type type = item->type;
1417   int i;
1418   spaces(fb, level);
1419   bprintf(fb, "%s: c%d #%d ", item->name, item->cls, item->number);
1420   if (item->cls == CC_STATIC || item->cls == CC_DYNAMIC)
1421     bprintf(fb, "t%d ", type);
1422   if (item->cls == CC_STATIC) {
1423     for (i=0; i<item->number; i++)
1424       dump_basic(fb, ptr + i * parsers[type].size, type, &item->u);
1425   } else if (item->cls == CC_DYNAMIC) {
1426     ptr = * (void**) ptr;
1427     if (ptr) {
1428       int real_nr = * (int*) (ptr - parsers[type].size);
1429       bprintf(fb, "##%d ", real_nr);
1430       for (i=0; i<real_nr; i++)
1431         dump_basic(fb, ptr + i * parsers[type].size, type, &item->u);
1432     } else
1433       bprintf(fb, "NULL ");
1434   }
1435   bputc(fb, '\n');
1436   if (item->cls == CC_SECTION)
1437     dump_section(fb, item->u.sec, level+1, ptr);
1438   else if (item->cls == CC_LIST) {
1439     uns idx = 0;
1440     struct cnode *n;
1441     CLIST_WALK(n, * (clist*) ptr) {
1442       spaces(fb, level+1);
1443       bprintf(fb, "item %d\n", ++idx);
1444       dump_section(fb, item->u.sec, level+2, n);
1445     }
1446   }
1447 }
1448
1449 static void
1450 dump_section(struct fastbuf *fb, struct cf_section *sec, int level, void *ptr)
1451 {
1452   spaces(fb, level);
1453   bprintf(fb, "S%d F%x:\n", sec->size, sec->flags);
1454   for (struct cf_item *item=sec->cfg; item->cls; item++)
1455     dump_item(fb, item, level, ptr);
1456 }
1457
1458 void
1459 cf_dump_sections(struct fastbuf *fb)
1460 {
1461   dump_section(fb, &sections, 0, NULL);
1462 }
1463
1464 /* TODO
1465  * - more space efficient journal
1466  */