2 * UCW Library -- Configuration files: interpreter
4 * (c) 2001--2006 Robert Spalek <robert@ucw.cz>
5 * (c) 2003--2006 Martin Mares <mj@ucw.cz>
7 * This software may be freely distributed and used according to the terms
8 * of the GNU Lesser General Public License.
13 #include "lib/getopt.h"
14 #include "lib/conf-internal.h"
15 #include "lib/clists.h"
20 #define TRY(f) do { byte *_msg = f; if (_msg) return _msg; } while (0)
22 /* Register size of and parser for each basic type */
25 cf_parse_string(byte *str, byte **ptr)
27 *ptr = cf_strdup(str);
31 typedef byte *cf_basic_parser(byte *str, void *ptr);
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
46 cf_type_size(enum cf_type type, struct cf_user_type *utype)
49 return parsers[type].size;
55 cf_parse_lookup(byte *str, int *ptr, byte **t)
59 while (*n && strcasecmp(*n, str)) {
60 total_len += strlen(*n) + 2;
67 byte *err = cf_malloc(total_len + strlen(str) + 60), *c = err;
68 c += sprintf(err, "Invalid value %s, possible values are: ", str);
70 c+= sprintf(c, "%s, ", *n);
78 cf_parse_ary(uns number, byte **pars, void *ptr, enum cf_type type, union cf_union *u)
80 for (uns i=0; i<number; i++)
83 uns size = cf_type_size(type, u->utype);
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);
93 return number > 1 ? cf_printf("Item %d: %s", i+1, msg) : msg;
101 byte *cf_op_names[] = { CF_OPERATIONS };
105 interpret_set_dynamic(struct cf_item *item, int number, byte **pars, void **ptr)
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);
118 interpret_add_dynamic(struct cf_item *item, int number, byte **pars, int *processed, void **ptr, enum cf_operation op)
120 enum cf_type type = item->type;
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);
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*));
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);
139 return cf_printf("Dynamic arrays do not support operation %s", cf_op_names[op]);
142 static byte *interpret_set_item(struct cf_item *item, int number, byte **pars, int *processed, void *ptr, uns allow_dynamic);
145 interpret_section(struct cf_section *sec, int number, byte **pars, int *processed, void *ptr, uns allow_dynamic)
147 cf_add_dirty(sec, ptr);
149 for (struct cf_item *ci=sec->cfg; ci->cls; ci++)
152 byte *msg = interpret_set_item(ci, number, pars, &taken, ptr + (addr_int_t) ci->ptr, allow_dynamic && !ci[1].cls);
154 return cf_printf("Item %s: %s", ci->name, msg);
158 if (!number) // stop parsing, because many parsers would otherwise complain that number==0
165 add_to_list(cnode *where, cnode *new_node, enum cf_operation op)
169 case OP_EDIT: // edition has been done in-place
172 CF_JOURNAL_VAR(where->prev->next);
173 CF_JOURNAL_VAR(where->next->prev);
176 case OP_AFTER: // implementation dependend (prepend_head = after(list)), and where==list, see clists.h:74
179 CF_JOURNAL_VAR(where->next->prev);
180 CF_JOURNAL_VAR(where->next);
181 clist_insert_after(new_node, where);
183 case OP_BEFORE: // implementation dependend (append_tail = before(list))
186 CF_JOURNAL_VAR(where->prev->next);
187 CF_JOURNAL_VAR(where->prev);
188 clist_insert_before(new_node, where);
196 interpret_add_list(struct cf_item *item, int number, byte **pars, int *processed, void *ptr, enum cf_operation op)
199 return cf_printf("You have to open a block for operation %s", cf_op_names[op]);
201 return "Nothing to add to the list";
202 struct cf_section *sec = item->u.sec;
207 void *node = cf_malloc(sec->size);
208 cf_init_section(item->name, sec, node, 1);
209 add_to_list(ptr, node, op);
211 /* If the node contains any dynamic attribute at the end, we suppress
212 * auto-repetition here and pass the flag inside instead. */
214 byte *msg = interpret_section(sec, number, pars, &taken, node, sec->flags & SEC_FLAG_DYNAMIC);
216 return sec->flags & SEC_FLAG_DYNAMIC ? msg : cf_printf("Node %d of list %s: %s", index, item->name, msg);
220 if (sec->flags & SEC_FLAG_DYNAMIC)
227 interpret_set_item(struct cf_item *item, int number, byte **pars, int *processed, void *ptr, uns allow_dynamic)
234 return "Missing value";
235 taken = MIN(number, item->number);
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);
242 return "Dynamic array cannot be used here";
243 taken = MIN(number, ABS(item->number));
245 return interpret_set_dynamic(item, taken, pars, ptr);
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));
253 for (int i=0; i<taken; i++)
254 pars[i] = cf_strdup(pars[i]);
255 return item->u.par(taken, pars, ptr);
257 return interpret_section(item->u.sec, number, pars, processed, ptr, allow_dynamic);
260 return "Lists cannot be used here";
261 return interpret_add_list(item, number, pars, processed, ptr, OP_SET);
268 interpret_clear(struct cf_item *item, void *ptr)
270 if (item->cls == CC_LIST) {
271 cf_journal_block(ptr, sizeof(clist));
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*));
280 return "The item is not a list, dynamic array, or string";
285 cmp_items(void *i1, void *i2, struct cf_item *item)
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));
297 find_list_node(clist *list, void *query, struct cf_section *sec, u32 mask)
299 CLIST_FOR_EACH(cnode *, n, *list)
302 for (uns i=0; i<32; i++)
304 if (cmp_items(n, query, sec->cfg+i))
316 record_selector(struct cf_item *item, struct cf_section *sec, u32 *mask)
318 uns nr = sec->flags & SEC_FLAG_NUMBER;
319 if (item >= sec->cfg && item < sec->cfg + nr) // setting an attribute relative to this section
321 uns i = item - sec->cfg;
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";
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];
343 opening_brace(struct cf_item *item, void *ptr, enum cf_operation op)
345 if (level >= MAX_STACK_SIZE-1)
346 return "Too many nested sections";
347 stack[++level] = (struct item_stack) {
355 if (!item) // unknown is ignored; we just need to trace recursion
357 stack[level].sec = item->u.sec;
358 if (item->cls == CC_SECTION)
360 stack[level].base_ptr = ptr;
361 stack[level].op = OP_EDIT | OP_2ND; // this list operation does nothing
363 else if (item->cls == CC_LIST)
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;
373 stack[level].op |= OP_1ST;
376 return "Opening brace can only be used on sections and lists";
381 closing_brace(struct item_stack *st, enum cf_operation op, int number, byte **pars)
383 if (st->op == OP_CLOSE) // top-level
384 return "Unmatched } parenthesis";
385 if (!st->sec) { // dummy run on unknown section
390 enum cf_operation pure_op = st->op & OP_MASK;
393 st->list = find_list_node(st->list, st->base_ptr, st->sec, st->mask);
395 return "Cannot find a node matching the query";
396 if (pure_op != OP_REMOVE)
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
407 TRY( st->sec->copy(st->base_ptr, st->list) );
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);
415 int taken; // parse parameters on 1 line immediately
416 TRY( interpret_section(st->sec, number, pars, &taken, st->base_ptr, 1) );
419 // and fall-thru to the 2nd phase
421 add_to_list(st->list, st->base_ptr, pure_op);
425 return "No parameters expected after the }";
426 else if (op & OP_OPEN)
427 return "No { is expected";
432 static struct cf_item *
433 find_item(struct cf_section *curr_sec, byte *name, byte **msg, void **ptr)
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
442 if (curr_sec != &cf_sections)
443 cf_add_dirty(curr_sec, *ptr);
444 byte *c = strchr(name, '.');
447 struct cf_item *ci = cf_find_subitem(curr_sec, name);
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);
454 *ptr += (addr_int_t) ci->ptr;
457 if (ci->cls != CC_SECTION)
459 *msg = cf_printf("Item %s is not a section", name);
462 curr_sec = ci->u.sec;
468 cf_interpret_line(byte *name, enum cf_operation op, int number, byte **pars)
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);
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
481 return "Cannot open a block after a parameter has been passed on a line";
482 return opening_brace(item, ptr, op);
484 if (!item) // ignored item in an unknown section
488 int taken; // process as many parameters as possible
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);
498 return cf_printf("Operation %s not supported on attribute %s", cf_op_names[op], name);
502 return cf_printf("Too many parameters: %d>%d", number, taken);
508 cf_find_item(byte *name, struct cf_item *item)
512 struct cf_item *ci = find_item(&cf_sections, name, &msg, &ptr);
519 bzero(item, sizeof(struct cf_item));
524 cf_write_item(struct cf_item *item, enum cf_operation op, int number, byte **pars)
530 msg = interpret_set_item(item, number, pars, &taken, item->ptr, 1);
534 msg = interpret_clear(item, item->ptr);
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);
543 return "The attribute class does not support append/prepend";
546 return "Unsupported operation";
551 return "Too many parameters";
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);
565 stack[0] = (struct item_stack) {
579 log(L_ERROR, "Unterminated block");