![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to conf_parser.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / starter / parser|
Return to conf_parser.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / starter / parser |
1.1 misho 1: /*
2: * Copyright (C) 2013-2014 Tobias Brunner
3: * HSR Hochschule fuer Technik Rapperswil
4: *
5: * This program is free software; you can redistribute it and/or modify it
6: * under the terms of the GNU General Public License as published by the
7: * Free Software Foundation; either version 2 of the License, or (at your
8: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
9: *
10: * This program is distributed in the hope that it will be useful, but
11: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
12: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13: * for more details.
14: */
15:
16: #include "conf_parser.h"
17:
18: #include <collections/array.h>
19: #include <collections/hashtable.h>
20:
21: /**
22: * Provided by the generated parser
23: */
24: bool conf_parser_parse_file(conf_parser_t *this, char *file);
25:
26: typedef struct private_conf_parser_t private_conf_parser_t;
27: typedef struct section_t section_t;
28:
29: /**
30: * Private data
31: */
32: struct private_conf_parser_t {
33:
34: /**
35: * Public interface
36: */
37: conf_parser_t public;
38:
39: /**
40: * Path to config file
41: */
42: char *file;
43:
44: /**
45: * TRUE while parsing the config file
46: */
47: bool parsing;
48:
49: /**
50: * Hashtable for ca sections, as section_t
51: */
52: hashtable_t *cas;
53:
54: /**
55: * Hashtable for conn sections, as section_t
56: */
57: hashtable_t *conns;
58:
59: /**
60: * Array to keep track of the order of conn sections, as section_t
61: */
62: array_t *conns_order;
63:
64: /**
65: * config setup section
66: */
67: section_t *config_setup;
68:
69: /**
70: * Pointer to the current section (the one added last) during parsing
71: */
72: section_t *current_section;
73:
74: /**
75: * Refcount for this parser instance (also used by dictionaries)
76: */
77: refcount_t ref;
78: };
79:
80: typedef struct {
81: /** Key of the setting */
82: char *key;
83: /** Value of the setting */
84: char *value;
85: } setting_t;
86:
87: int setting_find(const void *a, const void *b)
88: {
89: const char *key = a;
90: const setting_t *setting = b;
91: return strcmp(key, setting->key);
92: }
93:
94: int setting_sort(const void *a, const void *b, void *user)
95: {
96: const setting_t *sa = a, *sb = b;
97: return strcmp(sa->key, sb->key);
98: }
99:
100: static void setting_destroy(setting_t *this)
101: {
102: free(this->key);
103: free(this->value);
104: free(this);
105: }
106:
107: struct section_t {
108: /** Name of the section */
109: char *name;
110: /** Sorted array of settings, as setting_t */
111: array_t *settings;
112: /** Array of also= settings (in reversed order, i.e. most important to least
113: * important), as setting_t */
114: array_t *also;
115: /** Array of linearized parent objects derived from also= settings, in their
116: * order of importance (most to least, i.e. %default) as section_t
117: * NULL if not yet determined */
118: array_t *parents;
119: };
120:
121: static section_t *section_create(char *name)
122: {
123: section_t *this;
124:
125: INIT(this,
126: .name = name,
127: );
128: return this;
129: }
130:
131: static void section_destroy(section_t *this)
132: {
133: array_destroy_function(this->settings, (void*)setting_destroy, NULL);
134: array_destroy_function(this->also, (void*)setting_destroy, NULL);
135: array_destroy(this->parents);
136: free(this->name);
137: free(this);
138: }
139:
140: typedef struct {
141: /** Public interface */
142: dictionary_t public;
143: /** Parser object */
144: private_conf_parser_t *parser;
145: /** Section object */
146: section_t *section;
147: } section_dictionary_t;
148:
149: typedef struct {
150: /** Public interface */
151: enumerator_t public;
152: /** Current settings enumerator */
153: enumerator_t *settings;
154: /** Enumerator into parent list */
155: enumerator_t *parents;
156: /** Hashtable to keep track of already enumerated settings */
157: hashtable_t *seen;
158: } dictionary_enumerator_t;
159:
160: METHOD(enumerator_t, dictionary_enumerate, bool,
161: dictionary_enumerator_t *this, va_list args)
162: {
163: setting_t *setting;
164: section_t *parent;
165: char **key, **value;
166:
167: VA_ARGS_VGET(args, key, value);
168:
169: while (TRUE)
170: {
171: if (this->settings &&
172: this->settings->enumerate(this->settings, &setting))
173: {
174: if (this->seen->get(this->seen, setting->key))
175: {
176: continue;
177: }
178: this->seen->put(this->seen, setting->key, setting->key);
179: if (!setting->value)
180: {
181: continue;
182: }
183: if (key)
184: {
185: *key = setting->key;
186: }
187: if (value)
188: {
189: *value = setting->value;
190: }
191: return TRUE;
192: }
193: DESTROY_IF(this->settings);
194: this->settings = NULL;
195: if (this->parents &&
196: this->parents->enumerate(this->parents, &parent))
197: {
198: if (parent->settings)
199: {
200: this->settings = array_create_enumerator(parent->settings);
201: }
202: continue;
203: }
204: DESTROY_IF(this->parents);
205: this->parents = NULL;
206: break;
207: }
208: return FALSE;
209: }
210:
211: METHOD(enumerator_t, dictionary_enumerator_destroy, void,
212: dictionary_enumerator_t *this)
213: {
214: DESTROY_IF(this->settings);
215: DESTROY_IF(this->parents);
216: this->seen->destroy(this->seen);
217: free(this);
218: }
219:
220: METHOD(dictionary_t, dictionary_create_enumerator, enumerator_t*,
221: section_dictionary_t *this)
222: {
223: dictionary_enumerator_t *enumerator;
224:
225: INIT(enumerator,
226: .public = {
227: .enumerate = enumerator_enumerate_default,
228: .venumerate = _dictionary_enumerate,
229: .destroy = _dictionary_enumerator_destroy,
230: },
231: .seen = hashtable_create(hashtable_hash_str, hashtable_equals_str, 8),
232: );
233: if (this->section->settings)
234: {
235: enumerator->settings = array_create_enumerator(this->section->settings);
236: }
237: if (this->section->parents)
238: {
239: enumerator->parents = array_create_enumerator(this->section->parents);
240: }
241: return &enumerator->public;
242: }
243:
244: METHOD(dictionary_t, dictionary_get, void*,
245: section_dictionary_t *this, const void *key)
246: {
247: enumerator_t *parents;
248: section_t *section;
249: setting_t *setting;
250: char *value = NULL;
251:
252: section = this->section;
253: if (array_bsearch(section->settings, key, setting_find, &setting) != -1)
254: {
255: return setting->value;
256: }
257: parents = array_create_enumerator(section->parents);
258: while (parents->enumerate(parents, §ion))
259: {
260: if (array_bsearch(section->settings, key, setting_find, &setting) != -1)
261: {
262: value = setting->value;
263: break;
264: }
265: }
266: parents->destroy(parents);
267: return value;
268: }
269:
270: METHOD(dictionary_t, dictionary_destroy, void,
271: section_dictionary_t *this)
272: {
273: this->parser->public.destroy(&this->parser->public);
274: free(this);
275: }
276:
277: static dictionary_t *section_dictionary_create(private_conf_parser_t *parser,
278: section_t *section)
279: {
280: section_dictionary_t *this;
281:
282: INIT(this,
283: .public = {
284: .create_enumerator = _dictionary_create_enumerator,
285: .get = _dictionary_get,
286: .destroy = _dictionary_destroy,
287: },
288: .parser = parser,
289: .section = section,
290: );
291:
292: ref_get(&parser->ref);
293:
294: return &this->public;
295: }
296:
297: CALLBACK(conn_filter, bool,
298: void *unused, enumerator_t *orig, va_list args)
299: {
300: section_t *section;
301: char **name;
302:
303: VA_ARGS_VGET(args, name);
304:
305: while (orig->enumerate(orig, §ion))
306: {
307: if (!streq(section->name, "%default"))
308: {
309: *name = section->name;
310: return TRUE;
311: }
312: }
313: return FALSE;
314: }
315:
316: CALLBACK(ca_filter, bool,
317: void *unused, enumerator_t *orig, va_list args)
318: {
319: void *key;
320: section_t *section;
321: char **name;
322:
323: VA_ARGS_VGET(args, name);
324:
325: while (orig->enumerate(orig, &key, §ion))
326: {
327: if (!streq(section->name, "%default"))
328: {
329: *name = section->name;
330: return TRUE;
331: }
332: }
333: return FALSE;
334: }
335:
336: METHOD(conf_parser_t, get_sections, enumerator_t*,
337: private_conf_parser_t *this, conf_parser_section_t type)
338: {
339: switch (type)
340: {
341: case CONF_PARSER_CONN:
342: return enumerator_create_filter(
343: array_create_enumerator(this->conns_order),
344: conn_filter, NULL, NULL);
345: case CONF_PARSER_CA:
346: return enumerator_create_filter(
347: this->cas->create_enumerator(this->cas),
348: ca_filter, NULL, NULL);
349: case CONF_PARSER_CONFIG_SETUP:
350: default:
351: return enumerator_create_empty();
352: }
353: }
354:
355: METHOD(conf_parser_t, get_section, dictionary_t*,
356: private_conf_parser_t *this, conf_parser_section_t type, char *name)
357: {
358: section_t *section = NULL;
359:
360: if (name && streq(name, "%default"))
361: {
362: return NULL;
363: }
364: switch (type)
365: {
366: case CONF_PARSER_CONFIG_SETUP:
367: section = this->config_setup;
368: break;
369: case CONF_PARSER_CONN:
370: section = this->conns->get(this->conns, name);
371: break;
372: case CONF_PARSER_CA:
373: section = this->cas->get(this->cas, name);
374: break;
375: default:
376: break;
377: }
378: return section ? section_dictionary_create(this, section) : NULL;
379: }
380:
381: METHOD(conf_parser_t, add_section, bool,
382: private_conf_parser_t *this, conf_parser_section_t type, char *name)
383: {
384: hashtable_t *sections = this->conns;
385: array_t *order = this->conns_order;
386: section_t *section = NULL;
387: bool exists = FALSE;
388:
389: if (!this->parsing)
390: {
391: free(name);
392: return exists;
393: }
394: switch (type)
395: {
396: case CONF_PARSER_CONFIG_SETUP:
397: section = this->config_setup;
398: /* we don't expect a name, but just in case */
399: free(name);
400: break;
401: case CONF_PARSER_CA:
402: sections = this->cas;
403: order = NULL;
404: /* fall-through */
405: case CONF_PARSER_CONN:
406: section = sections->get(sections, name);
407: if (!section)
408: {
409: section = section_create(name);
410: sections->put(sections, name, section);
411: if (order)
412: {
413: array_insert(order, ARRAY_TAIL, section);
414: }
415: }
416: else
417: {
418: exists = TRUE;
419: free(name);
420: }
421: break;
422:
423: }
424: this->current_section = section;
425: return exists;
426: }
427:
428: METHOD(conf_parser_t, add_setting, void,
429: private_conf_parser_t *this, char *key, char *value)
430: {
431: section_t *section = this->current_section;
432: setting_t *setting;
433:
434: if (!this->parsing || !this->current_section)
435: {
436: free(key);
437: free(value);
438: return;
439: }
440: if (streq(key, "also"))
441: {
442: if (!value || !strlen(value) || streq(value, "%default"))
443: { /* we require a name, but all sections inherit from %default */
444: free(key);
445: free(value);
446: return;
447: }
448: INIT(setting,
449: .key = key,
450: .value = value,
451: );
452: array_insert_create(§ion->also, ARRAY_HEAD, setting);
453: return;
454: }
455: if (array_bsearch(section->settings, key, setting_find, &setting) == -1)
456: {
457: INIT(setting,
458: .key = key,
459: .value = value,
460: );
461: array_insert_create(§ion->settings, ARRAY_TAIL, setting);
462: array_sort(section->settings, setting_sort, NULL);
463: }
464: else
465: {
466: free(setting->value);
467: setting->value = value;
468: free(key);
469: }
470: }
471:
472: /**
473: * Check if the given section is contained in the given array. The search
474: * starts at the given index.
475: */
476: static bool is_contained_in(array_t *arr, section_t *section)
477: {
478: section_t *current;
479: int i;
480:
481: for (i = 0; i < array_count(arr); i++)
482: {
483: array_get(arr, i, ¤t);
484: if (streq(section->name, current->name))
485: {
486: return TRUE;
487: }
488: }
489: return FALSE;
490: }
491:
492: /**
493: * This algorithm to linearize sections uses a bottom-first depth-first
494: * semantic, with an additional elimination step that removes all but the
495: * last occurrence of each section.
496: *
497: * Consider this configuration:
498: *
499: * conn A
500: * conn B
501: * also=A
502: * conn C
503: * also=A
504: * conn D
505: * also=C
506: * also=B
507: *
508: * The linearization would yield D B A C A, which gets reduced to D B C A.
509: *
510: * Ambiguous configurations are handled pragmatically.
511: *
512: * Consider the following configuration:
513: *
514: * conn A
515: * conn B
516: * conn C
517: * also=A
518: * also=B
519: * conn D
520: * also=B
521: * also=A
522: * conn E
523: * also=C
524: * also=D
525: *
526: * It is ambiguous because D and C include the same two sections but in
527: * a different order.
528: *
529: * The linearization would yield E D A B C B A which gets reduced to E D C B A.
530: */
531: static bool resolve_also_single(hashtable_t *sections,
532: section_t *section, section_t *def, array_t *stack)
533: {
534: enumerator_t *enumerator;
535: array_t *parents;
536: section_t *parent, *grandparent;
537: setting_t *also;
538: bool success = TRUE;
539: int i;
540:
541: array_insert(stack, ARRAY_HEAD, section);
542: parents = array_create(0, 0);
543: enumerator = array_create_enumerator(section->also);
544: while (enumerator->enumerate(enumerator, &also))
545: {
546: parent = sections->get(sections, also->value);
547: if (!parent || is_contained_in(stack, parent))
548: {
549: if (!parent)
550: {
551: DBG1(DBG_CFG, "section '%s' referenced in section '%s' not "
552: "found", also->value, section->name);
553: }
554: else
555: {
556: DBG1(DBG_CFG, "section '%s' referenced in section '%s' causes "
557: "a loop", parent->name, section->name);
558: }
559: array_remove_at(section->also, enumerator);
560: setting_destroy(also);
561: success = FALSE;
562: continue;
563: }
564: if (!parent->parents)
565: {
566: if (!resolve_also_single(sections, parent, def, stack))
567: {
568: success = FALSE;
569: continue;
570: }
571: }
572: /* add the grandparents and the parent to the list */
573: array_insert(parents, ARRAY_TAIL, parent);
574: for (i = 0; i < array_count(parent->parents); i++)
575: {
576: array_get(parent->parents, i, &grandparent);
577: array_insert(parents, ARRAY_TAIL, grandparent);
578: }
579: }
580: enumerator->destroy(enumerator);
581: array_remove(stack, ARRAY_HEAD, NULL);
582:
583: if (success && def && !array_count(parents))
584: {
585: array_insert(parents, ARRAY_TAIL, def);
586: }
587:
588: while (success && array_remove(parents, ARRAY_HEAD, &parent))
589: {
590: if (!is_contained_in(parents, parent))
591: { /* last occurrence of this section */
592: array_insert_create(§ion->parents, ARRAY_TAIL, parent);
593: }
594: }
595: array_destroy(parents);
596: return success;
597: }
598:
599: /**
600: * Resolve also= statements. The functions returns TRUE if everything is fine,
601: * or FALSE if either a referenced section does not exist, or if the section
602: * inheritance can't be determined properly (e.g. if there are loops or if a
603: * section inherits from multiple sections - perhaps over several levels - in
604: * an ambiguous way).
605: */
606: static bool resolve_also(hashtable_t *sections)
607: {
608: enumerator_t *enumerator;
609: section_t *def, *section;
610: array_t *stack;
611: bool success = TRUE;
612:
613: stack = array_create(0, 0);
614:
615: def = sections->get(sections, "%default");
616: if (def)
617: { /* the default section is the only one with an empty parents list */
618: def->parents = array_create(0, 0);
619: }
620: enumerator = sections->create_enumerator(sections);
621: while (enumerator->enumerate(enumerator, NULL, §ion))
622: {
623: if (section->parents)
624: { /* already determined */
625: continue;
626: }
627: success = resolve_also_single(sections, section, def, stack) && success;
628: }
629: enumerator->destroy(enumerator);
630: array_destroy(stack);
631: return success;
632: }
633:
634: METHOD(conf_parser_t, parse, bool,
635: private_conf_parser_t *this)
636: {
637: bool success;
638:
639: if (!this->file)
640: { /* no file, lets assume this is OK */
641: return TRUE;
642: }
643: this->parsing = TRUE;
644: success = conf_parser_parse_file(&this->public, this->file);
645: this->parsing = FALSE;
646: return success && resolve_also(this->conns) && resolve_also(this->cas);
647: }
648:
649: METHOD(conf_parser_t, destroy, void,
650: private_conf_parser_t *this)
651: {
652: if (ref_put(&this->ref))
653: {
654: this->cas->destroy_function(this->cas, (void*)section_destroy);
655: this->conns->destroy_function(this->conns, (void*)section_destroy);
656: section_destroy(this->config_setup);
657: array_destroy(this->conns_order);
658: free(this->file);
659: free(this);
660: }
661: }
662:
663: /*
664: * Described in header
665: */
666: conf_parser_t *conf_parser_create(const char *file)
667: {
668: private_conf_parser_t *this;
669:
670: INIT(this,
671: .public = {
672: .parse = _parse,
673: .get_sections = _get_sections,
674: .get_section = _get_section,
675: .add_section = _add_section,
676: .add_setting = _add_setting,
677: .destroy = _destroy,
678: },
679: .file = strdupnull(file),
680: .cas = hashtable_create(hashtable_hash_str,
681: hashtable_equals_str, 8),
682: .conns = hashtable_create(hashtable_hash_str,
683: hashtable_equals_str, 8),
684: .conns_order = array_create(0, 0),
685: .config_setup = section_create(NULL),
686: .ref = 1,
687: );
688:
689: return &this->public;
690: }