lib/conf-intr.c

   1 /*
   2  *      UCW Library -- Configuration files: interpreter
   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/conf.h"
  13 #include "lib/getopt.h"
  14 #include "lib/conf-internal.h"
  15 #include "lib/clists.h"
  16
  17 #include <string.h>
  18 #include <stdio.h>
  19
  20 #define TRY(f)  do { byte *_msg = f; if (_msg) return _msg; } while (0)
  21
  22 /* Register size of and parser for each basic type */
  23
  24 static byte *
  25 cf_parse_string(byte *str, byte **ptr)
  26 {
  27   *ptr = cf_strdup(str);
  28   return NULL;
  29 }
  30
  31 typedef byte *cf_basic_parser(byte *str, void *ptr);
  32 static struct {
  33   uns size;
  34   void *parser;
  35 } parsers[] = {
  36   { sizeof(int), cf_parse_int },
  37   { sizeof(u64), cf_parse_u64 },
  38   { sizeof(double), cf_parse_double },
  39   { sizeof(u32), cf_parse_ip },
  40   { sizeof(byte*), cf_parse_string },
  41   { sizeof(int), NULL },                        // lookups are parsed extra
  42   { 0, NULL },                                  // user-defined types are parsed extra
  43 };
  44
  45 inline uns
  46 cf_type_size(enum cf_type type, struct cf_user_type *utype)
  47 {
  48   if (type < CT_USER)
  49     return parsers[type].size;
  50   else
  51     return utype->size;
  52 }
  53
  54 static byte *
  55 cf_parse_lookup(byte *str, int *ptr, byte **t)
  56 {
  57   byte **n = t;
  58   uns total_len = 0;
  59   while (*n && strcasecmp(*n, str)) {
  60     total_len += strlen(*n) + 2;
  61     n++;
  62   }
  63   if (*n) {
  64     *ptr = n - t;
  65     return NULL;
  66   }
  67   byte *err = cf_malloc(total_len + strlen(str) + 60), *c = err;
  68   c += sprintf(err, "Invalid value %s, possible values are: ", str);
  69   for (n=t; *n; n++)
  70     c+= sprintf(c, "%s, ", *n);
  71   if (*t)
  72     c[-2] = 0;
  73   *ptr = -1;
  74   return err;
  75 }
  76
  77 static byte *
  78 cf_parse_ary(uns number, byte **pars, void *ptr, enum cf_type type, union cf_union *u)
  79 {
  80   for (uns i=0; i<number; i++)
  81   {
  82     byte *msg;
  83     uns size = cf_type_size(type, u->utype);
  84     if (type < CT_LOOKUP)
  85       msg = ((cf_basic_parser*) parsers[type].parser) (pars[i], ptr + i * size);
  86     else if (type == CT_LOOKUP)
  87       msg = cf_parse_lookup(pars[i], ptr + i * size, u->lookup);
  88     else if (type == CT_USER)
  89       msg = u->utype->parser(pars[i], ptr + i * size);
  90     else
  91       ASSERT(0);
  92     if (msg)
  93       return number > 1 ? cf_printf("Item %d: %s", i+1, msg) : msg;
  94   }
  95   return NULL;
  96 }
  97
  98 /* Interpreter */
  99
 100 #define T(x) #x,
 101 byte *cf_op_names[] = { CF_OPERATIONS };
 102 #undef T
 103
 104 static byte *
 105 interpret_set_dynamic(struct cf_item *item, int number, byte **pars, void **ptr)
 106 {
 107   enum cf_type type = item->type;
 108   cf_journal_block(ptr, sizeof(void*));
 109   // boundary checks done by the caller
 110   uns size = cf_type_size(item->type, item->u.utype);
 111   ASSERT(size >= sizeof(uns));
 112   *ptr = cf_malloc((number+1) * size) + size;
 113   * (uns*) (*ptr - size) = number;
 114   return cf_parse_ary(number, pars, *ptr, type, &item->u);
 115 }
 116
 117 static byte *
 118 interpret_add_dynamic(struct cf_item *item, int number, byte **pars, int *processed, void **ptr, enum cf_operation op)
 119 {
 120   enum cf_type type = item->type;
 121   void *old_p = *ptr;
 122   uns size = cf_type_size(item->type, item->u.utype);
 123   ASSERT(size >= sizeof(uns));
 124   int old_nr = old_p ? * (int*) (old_p - size) : 0;
 125   int taken = MIN(number, ABS(item->number)-old_nr);
 126   *processed = taken;
 127   // stretch the dynamic array
 128   void *new_p = cf_malloc((old_nr + taken + 1) * size) + size;
 129   * (uns*) (new_p - size) = old_nr + taken;
 130   cf_journal_block(ptr, sizeof(void*));
 131   *ptr = new_p;
 132   if (op == OP_APPEND) {
 133     memcpy(new_p, old_p, old_nr * size);
 134     return cf_parse_ary(taken, pars, new_p + old_nr * size, type, &item->u);
 135   } else if (op == OP_PREPEND) {
 136     memcpy(new_p + taken * size, old_p, old_nr * size);
 137     return cf_parse_ary(taken, pars, new_p, type, &item->u);
 138   } else
 139     return cf_printf("Dynamic arrays do not support operation %s", cf_op_names[op]);
 140 }
 141
 142 static byte *interpret_set_item(struct cf_item *item, int number, byte **pars, int *processed, void *ptr, uns allow_dynamic);
 143
 144 static byte *
 145 interpret_section(struct cf_section *sec, int number, byte **pars, int *processed, void *ptr, uns allow_dynamic)
 146 {
 147   cf_add_dirty(sec, ptr);
 148   *processed = 0;
 149   for (struct cf_item *ci=sec->cfg; ci->cls; ci++)
 150   {
 151     int taken;
 152     byte *msg = interpret_set_item(ci, number, pars, &taken, ptr + (addr_int_t) ci->ptr, allow_dynamic && !ci[1].cls);
 153     if (msg)
 154       return cf_printf("Item %s: %s", ci->name, msg);
 155     *processed += taken;
 156     number -= taken;
 157     pars += taken;
 158     if (!number)                // stop parsing, because many parsers would otherwise complain that number==0
 159       break;
 160   }
 161   return NULL;
 162 }
 163
 164 static void
 165 add_to_list(cnode *where, cnode *new_node, enum cf_operation op)
 166 {
 167   switch (op)
 168   {
 169     case OP_EDIT:               // edition has been done in-place
 170       break;
 171     case OP_REMOVE:
 172       CF_JOURNAL_VAR(where->prev->next);
 173       CF_JOURNAL_VAR(where->next->prev);
 174       clist_remove(where);
 175       break;
 176     case OP_AFTER:              // implementation dependend (prepend_head = after(list)), and where==list, see clists.h:74
 177     case OP_PREPEND:
 178     case OP_COPY:
 179       CF_JOURNAL_VAR(where->next->prev);
 180       CF_JOURNAL_VAR(where->next);
 181       clist_insert_after(new_node, where);
 182       break;
 183     case OP_BEFORE:             // implementation dependend (append_tail = before(list))
 184     case OP_APPEND:
 185     case OP_SET:
 186       CF_JOURNAL_VAR(where->prev->next);
 187       CF_JOURNAL_VAR(where->prev);
 188       clist_insert_before(new_node, where);
 189       break;
 190     default:
 191       ASSERT(0);
 192   }
 193 }
 194
 195 static byte *
 196 interpret_add_list(struct cf_item *item, int number, byte **pars, int *processed, void *ptr, enum cf_operation op)
 197 {
 198   if (op >= OP_REMOVE)
 199     return cf_printf("You have to open a block for operation %s", cf_op_names[op]);
 200   if (!number)
 201     return "Nothing to add to the list";
 202   struct cf_section *sec = item->u.sec;
 203   *processed = 0;
 204   uns index = 0;
 205   while (number > 0)
 206   {
 207     void *node = cf_malloc(sec->size);
 208     cf_init_section(item->name, sec, node, 1);
 209     add_to_list(ptr, node, op);
 210     int taken;
 211     /* If the node contains any dynamic attribute at the end, we suppress
 212      * auto-repetition here and pass the flag inside instead.  */
 213     index++;
 214     byte *msg = interpret_section(sec, number, pars, &taken, node, sec->flags & SEC_FLAG_DYNAMIC);
 215     if (msg)
 216       return sec->flags & SEC_FLAG_DYNAMIC ? msg : cf_printf("Node %d of list %s: %s", index, item->name, msg);
 217     *processed += taken;
 218     number -= taken;
 219     pars += taken;
 220     if (sec->flags & SEC_FLAG_DYNAMIC)
 221       break;
 222   }
 223   return NULL;
 224 }
 225
 226 static byte *
 227 interpret_set_item(struct cf_item *item, int number, byte **pars, int *processed, void *ptr, uns allow_dynamic)
 228 {
 229   int taken;
 230   switch (item->cls)
 231   {
 232     case CC_STATIC:
 233       if (!number)
 234         return "Missing value";
 235       taken = MIN(number, item->number);
 236       *processed = taken;
 237       uns size = cf_type_size(item->type, item->u.utype);
 238       cf_journal_block(ptr, taken * size);
 239       return cf_parse_ary(taken, pars, ptr, item->type, &item->u);
 240     case CC_DYNAMIC:
 241       if (!allow_dynamic)
 242         return "Dynamic array cannot be used here";
 243       taken = MIN(number, ABS(item->number));
 244       *processed = taken;
 245       return interpret_set_dynamic(item, taken, pars, ptr);
 246     case CC_PARSER:
 247       if (item->number < 0 && !allow_dynamic)
 248         return "Parsers with variable number of parameters cannot be used here";
 249       if (item->number > 0 && number < item->number)
 250         return "Not enough parameters available for the parser";
 251       taken = MIN(number, ABS(item->number));
 252       *processed = taken;
 253       for (int i=0; i<taken; i++)
 254         pars[i] = cf_strdup(pars[i]);
 255       return item->u.par(taken, pars, ptr);
 256     case CC_SECTION:
 257       return interpret_section(item->u.sec, number, pars, processed, ptr, allow_dynamic);
 258     case CC_LIST:
 259       if (!allow_dynamic)
 260         return "Lists cannot be used here";
 261       return interpret_add_list(item, number, pars, processed, ptr, OP_SET);
 262     default:
 263       ASSERT(0);
 264   }
 265 }
 266
 267 static byte *
 268 interpret_clear(struct cf_item *item, void *ptr)
 269 {
 270   if (item->cls == CC_LIST) {
 271     cf_journal_block(ptr, sizeof(clist));
 272     clist_init(ptr);
 273   } else if (item->cls == CC_DYNAMIC) {
 274     cf_journal_block(ptr, sizeof(void *));
 275     * (void**) ptr = NULL;
 276   } else if (item->cls == CC_STATIC && item->type == CT_STRING) {
 277     cf_journal_block(ptr, item->number * sizeof(byte*));
 278     bzero(ptr, item->number * sizeof(byte*));
 279   } else
 280     return "The item is not a list, dynamic array, or string";
 281   return NULL;
 282 }
 283
 284 static int
 285 cmp_items(void *i1, void *i2, struct cf_item *item)
 286 {
 287   ASSERT(item->cls == CC_STATIC);
 288   i1 += (addr_int_t) item->ptr;
 289   i2 += (addr_int_t) item->ptr;
 290   if (item->type == CT_STRING)
 291     return strcmp(* (byte**) i1, * (byte**) i2);
 292   else                          // all numeric types
 293     return memcmp(i1, i2, cf_type_size(item->type, item->u.utype));
 294 }
 295
 296 static void *
 297 find_list_node(clist *list, void *query, struct cf_section *sec, u32 mask)
 298 {
 299   CLIST_FOR_EACH(cnode *, n, *list)
 300   {
 301     uns found = 1;
 302     for (uns i=0; i<32; i++)
 303       if (mask & (1<<i))
 304         if (cmp_items(n, query, sec->cfg+i))
 305         {
 306           found = 0;
 307           break;
 308         }
 309     if (found)
 310       return n;
 311   }
 312   return NULL;
 313 }
 314
 315 static byte *
 316 record_selector(struct cf_item *item, struct cf_section *sec, u32 *mask)
 317 {
 318   uns nr = sec->flags & SEC_FLAG_NUMBER;
 319   if (item >= sec->cfg && item < sec->cfg + nr) // setting an attribute relative to this section
 320   {
 321     uns i = item - sec->cfg;
 322     if (i >= 32)
 323       return "Cannot select list nodes by this attribute";
 324     if (sec->cfg[i].cls != CC_STATIC)
 325       return "Selection can only be done based on basic attributes";
 326     *mask |= 1 << i;
 327   }
 328   return NULL;
 329 }
 330
 331 #define MAX_STACK_SIZE  10
 332 static struct item_stack {
 333   struct cf_section *sec;       // nested section
 334   void *base_ptr;               // because original pointers are often relative
 335   enum cf_operation op;         // it is performed when a closing brace is encountered
 336   void *list;                   // list the operations should be done on
 337   u32 mask;                     // bit array of selectors searching in a list
 338   struct cf_item *item;         // cf_item of the list
 339 } stack[MAX_STACK_SIZE];
 340 static uns level;
 341
 342 static byte *
 343 opening_brace(struct cf_item *item, void *ptr, enum cf_operation op)
 344 {
 345   if (level >= MAX_STACK_SIZE-1)
 346     return "Too many nested sections";
 347   stack[++level] = (struct item_stack) {
 348     .sec = NULL,
 349     .base_ptr = NULL,
 350     .op = op & OP_MASK,
 351     .list = NULL,
 352     .mask = 0,
 353     .item = NULL,
 354   };
 355   if (!item)                    // unknown is ignored; we just need to trace recursion
 356     return NULL;
 357   stack[level].sec = item->u.sec;
 358   if (item->cls == CC_SECTION)
 359   {
 360     stack[level].base_ptr = ptr;
 361     stack[level].op = OP_EDIT | OP_2ND; // this list operation does nothing
 362   }
 363   else if (item->cls == CC_LIST)
 364   {
 365     stack[level].base_ptr = cf_malloc(item->u.sec->size);
 366     cf_init_section(item->name, item->u.sec, stack[level].base_ptr, 1);
 367     stack[level].list = ptr;
 368     stack[level].item = item;
 369     if ((op & OP_MASK) < OP_REMOVE) {
 370       add_to_list(ptr, stack[level].base_ptr, op & OP_MASK);
 371       stack[level].op |= OP_2ND;
 372     } else
 373       stack[level].op |= OP_1ST;
 374   }
 375   else
 376     return "Opening brace can only be used on sections and lists";
 377   return NULL;
 378 }
 379
 380 static byte *
 381 closing_brace(struct item_stack *st, enum cf_operation op, int number, byte **pars)
 382 {
 383   if (st->op == OP_CLOSE)       // top-level
 384     return "Unmatched } parenthesis";
 385   if (!st->sec) {               // dummy run on unknown section
 386     if (!(op & OP_OPEN))
 387       level--;
 388     return NULL;
 389   }
 390   enum cf_operation pure_op = st->op & OP_MASK;
 391   if (st->op & OP_1ST)
 392   {
 393     st->list = find_list_node(st->list, st->base_ptr, st->sec, st->mask);
 394     if (!st->list)
 395       return "Cannot find a node matching the query";
 396     if (pure_op != OP_REMOVE)
 397     {
 398       if (pure_op == OP_EDIT)
 399         st->base_ptr = st->list;
 400       else if (pure_op == OP_AFTER || pure_op == OP_BEFORE)
 401         cf_init_section(st->item->name, st->sec, st->base_ptr, 1);
 402       else if (pure_op == OP_COPY) {
 403         if (st->sec->flags & SEC_FLAG_CANT_COPY)
 404           return cf_printf("Item %s cannot be copied", st->item->name);
 405         memcpy(st->base_ptr, st->list, st->sec->size);  // strings and dynamic arrays are shared
 406         if (st->sec->copy)
 407           TRY( st->sec->copy(st->base_ptr, st->list) );
 408       } else
 409         ASSERT(0);
 410       if (op & OP_OPEN) {       // stay at the same recursion level
 411         st->op = (st->op | OP_2ND) & ~OP_1ST;
 412         add_to_list(st->list, st->base_ptr, pure_op);
 413         return NULL;
 414       }
 415       int taken;                // parse parameters on 1 line immediately
 416       TRY( interpret_section(st->sec, number, pars, &taken, st->base_ptr, 1) );
 417       number -= taken;
 418       pars += taken;
 419       // and fall-thru to the 2nd phase
 420     }
 421     add_to_list(st->list, st->base_ptr, pure_op);
 422   }
 423   level--;
 424   if (number)
 425     return "No parameters expected after the }";
 426   else if (op & OP_OPEN)
 427     return "No { is expected";
 428   else
 429     return NULL;
 430 }
 431
 432 static struct cf_item *
 433 find_item(struct cf_section *curr_sec, byte *name, byte **msg, void **ptr)
 434 {
 435   *msg = NULL;
 436   if (name[0] == '^')                           // absolute name instead of relative
 437     name++, curr_sec = &cf_sections, *ptr = NULL;
 438   if (!curr_sec)                                // don't even search in an unknown section
 439     return NULL;
 440   while (1)
 441   {
 442     if (curr_sec != &cf_sections)
 443       cf_add_dirty(curr_sec, *ptr);
 444     byte *c = strchr(name, '.');
 445     if (c)
 446       *c++ = 0;
 447     struct cf_item *ci = cf_find_subitem(curr_sec, name);
 448     if (!ci->cls)
 449     {
 450       if (!(curr_sec->flags & SEC_FLAG_UNKNOWN))        // ignore silently unknown top-level sections and unknown attributes in flagged sections
 451         *msg = cf_printf("Unknown item %s", name);
 452       return NULL;
 453     }
 454     *ptr += (addr_int_t) ci->ptr;
 455     if (!c)
 456       return ci;
 457     if (ci->cls != CC_SECTION)
 458     {
 459       *msg = cf_printf("Item %s is not a section", name);
 460       return NULL;
 461     }
 462     curr_sec = ci->u.sec;
 463     name = c;
 464   }
 465 }
 466
 467 byte *
 468 cf_interpret_line(byte *name, enum cf_operation op, int number, byte **pars)
 469 {
 470   byte *msg;
 471   if ((op & OP_MASK) == OP_CLOSE)
 472     return closing_brace(stack+level, op, number, pars);
 473   void *ptr = stack[level].base_ptr;
 474   struct cf_item *item = find_item(stack[level].sec, name, &msg, &ptr);
 475   if (msg)
 476     return msg;
 477   if (stack[level].op & OP_1ST)
 478     TRY( record_selector(item, stack[level].sec, &stack[level].mask) );
 479   if (op & OP_OPEN) {           // the operation will be performed after the closing brace
 480     if (number)
 481       return "Cannot open a block after a parameter has been passed on a line";
 482     return opening_brace(item, ptr, op);
 483   }
 484   if (!item)                    // ignored item in an unknown section
 485     return NULL;
 486   op &= OP_MASK;
 487
 488   int taken;                    // process as many parameters as possible
 489   if (op == OP_CLEAR)
 490     taken = 0, msg = interpret_clear(item, ptr);
 491   else if (op == OP_SET)
 492     msg = interpret_set_item(item, number, pars, &taken, ptr, 1);
 493   else if (item->cls == CC_DYNAMIC)
 494     msg = interpret_add_dynamic(item, number, pars, &taken, ptr, op);
 495   else if (item->cls == CC_LIST)
 496     msg = interpret_add_list(item, number, pars, &taken, ptr, op);
 497   else
 498     return cf_printf("Operation %s not supported on attribute %s", cf_op_names[op], name);
 499   if (msg)
 500     return msg;
 501   if (taken < number)
 502     return cf_printf("Too many parameters: %d>%d", number, taken);
 503
 504   return NULL;
 505 }
 506
 507 byte *
 508 cf_find_item(byte *name, struct cf_item *item)
 509 {
 510   byte *msg;
 511   void *ptr;
 512   struct cf_item *ci = find_item(&cf_sections, name, &msg, &ptr);
 513   if (msg)
 514     return msg;
 515   if (ci) {
 516     *item = *ci;
 517     item->ptr = ptr;
 518   } else
 519     bzero(item, sizeof(struct cf_item));
 520   return NULL;
 521 }
 522
 523 byte *
 524 cf_write_item(struct cf_item *item, enum cf_operation op, int number, byte **pars)
 525 {
 526   byte *msg;
 527   int taken;
 528   switch (op) {
 529     case OP_SET:
 530       msg = interpret_set_item(item, number, pars, &taken, item->ptr, 1);
 531       break;
 532     case OP_CLEAR:
 533       taken = 0;
 534       msg = interpret_clear(item, item->ptr);
 535       break;
 536     case OP_APPEND:
 537     case OP_PREPEND:
 538       if (item->cls == CC_DYNAMIC)
 539         msg = interpret_add_dynamic(item, number, pars, &taken, item->ptr, op);
 540       else if (item->cls == CC_LIST)
 541         msg = interpret_add_list(item, number, pars, &taken, item->ptr, op);
 542       else
 543         return "The attribute class does not support append/prepend";
 544       break;
 545     default:
 546       return "Unsupported operation";
 547   }
 548   if (msg)
 549     return msg;
 550   if (taken < number)
 551     return "Too many parameters";
 552   return NULL;
 553 }
 554
 555 void
 556 cf_init_stack(void)
 557 {
 558   static uns initialized = 0;
 559   if (!initialized++) {
 560     cf_sections.flags |= SEC_FLAG_UNKNOWN;
 561     cf_sections.size = 0;                       // size of allocated array used to be stored here
 562     cf_init_section(NULL, &cf_sections, NULL, 0);
 563   }
 564   level = 0;
 565   stack[0] = (struct item_stack) {
 566     .sec = &cf_sections,
 567     .base_ptr = NULL,
 568     .op = OP_CLOSE,
 569     .list = NULL,
 570     .mask = 0,
 571     .item = NULL
 572   };
 573 }
 574
 575 int
 576 cf_check_stack(void)
 577 {
 578   if (level > 0) {
 579     log(L_ERROR, "Unterminated block");
 580     return 1;
 581   }
 582   return 0;
 583 }
 584