![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to settings.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 / libstrongswan / settings|
Return to settings.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / settings |
1.1 misho 1: /*
2: * Copyright (C) 2010-2018 Tobias Brunner
3: * Copyright (C) 2008 Martin Willi
4: * HSR Hochschule fuer Technik Rapperswil
5: *
6: * This program is free software; you can redistribute it and/or modify it
7: * under the terms of the GNU General Public License as published by the
8: * Free Software Foundation; either version 2 of the License, or (at your
9: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
10: *
11: * This program is distributed in the hope that it will be useful, but
12: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14: * for more details.
15: */
16:
17: #define _GNU_SOURCE
18: #include <string.h>
19: #include <stdarg.h>
20: #include <stdio.h>
21: #include <errno.h>
22: #include <limits.h>
23: #include <sys/types.h>
24: #include <sys/stat.h>
25: #include <unistd.h>
26: #include <ctype.h>
27:
28: #include "settings.h"
29: #include "settings_types.h"
30:
31: #include "collections/array.h"
32: #include "collections/hashtable.h"
33: #include "collections/linked_list.h"
34: #include "threading/rwlock.h"
35: #include "utils/debug.h"
36:
37: typedef struct private_settings_t private_settings_t;
38:
39: /**
40: * Parse functions provided by the generated parser.
41: */
42: bool settings_parser_parse_file(section_t *root, char *name);
43: bool settings_parser_parse_string(section_t *root, char *settings);
44:
45: /**
46: * Private data of settings
47: */
48: struct private_settings_t {
49:
50: /**
51: * Public interface
52: */
53: settings_t public;
54:
55: /**
56: * Top level section
57: */
58: section_t *top;
59:
60: /**
61: * Contents of replaced settings (char*)
62: *
63: * FIXME: This is required because the pointer returned by get_str()
64: * is not refcounted. Might cause ever increasing usage stats.
65: */
66: array_t *contents;
67:
68: /**
69: * Lock to safely access the settings
70: */
71: rwlock_t *lock;
72: };
73:
74: /**
75: * Print a format key, but consume already processed arguments
76: * Note that key and start point into the same string
77: */
78: static bool print_key(char *buf, int len, char *start, char *key, va_list args)
79: {
80: va_list copy;
81: char *pos = start;
82: bool res;
83:
84: va_copy(copy, args);
85: while (TRUE)
86: {
87: pos = memchr(pos, '%', key - pos);
88: if (!pos)
89: {
90: break;
91: }
92: pos++;
93: switch (*pos)
94: {
95: case 'd':
96: va_arg(copy, int);
97: break;
98: case 's':
99: va_arg(copy, char*);
100: break;
101: case 'N':
102: va_arg(copy, enum_name_t*);
103: va_arg(copy, int);
104: break;
105: case '%':
106: break;
107: default:
108: DBG1(DBG_CFG, "settings with %%%c not supported!", *pos);
109: break;
110: }
111: pos++;
112: }
113: res = vsnprintf(buf, len, key, copy) < len;
114: va_end(copy);
115: return res;
116: }
117:
118: /**
119: * Check if the given section is contained in the given array.
120: */
121: static bool has_section(array_t *array, section_t *section)
122: {
123: section_t *current;
124: int i;
125:
126: for (i = 0; i < array_count(array); i++)
127: {
128: array_get(array, i, ¤t);
129: if (current == section)
130: {
131: return TRUE;
132: }
133: }
134: return FALSE;
135: }
136:
137: /**
138: * Find a section by a given key, using buffered key, reusable buffer.
139: * If "ensure" is TRUE, the sections are created if they don't exist.
140: */
141: static section_t *find_section_buffered(section_t *section,
142: char *start, char *key, va_list args, char *buf, int len,
143: bool ensure)
144: {
145: char *pos;
146: section_t *found = NULL;
147:
148: if (section == NULL)
149: {
150: return NULL;
151: }
152: pos = strchr(key, '.');
153: if (pos)
154: {
155: *pos = '\0';
156: pos++;
157: }
158: if (!print_key(buf, len, start, key, args))
159: {
160: return NULL;
161: }
162: if (!strlen(buf))
163: {
164: found = section;
165: }
166: else if (array_bsearch(section->sections, buf, settings_section_find,
167: &found) == -1)
168: {
169: if (ensure)
170: {
171: found = settings_section_create(strdup(buf));
172: settings_section_add(section, found, NULL);
173: }
174: }
175: if (found && pos)
176: {
177: return find_section_buffered(found, start, pos, args, buf, len, ensure);
178: }
179: return found;
180: }
181:
182: /**
183: * Forward declaration
184: */
185: static array_t *find_sections(private_settings_t *this, section_t *section,
186: char *key, va_list args, array_t **sections);
187:
188: /**
189: * Resolve the given reference. Not thread-safe.
190: * Only a vararg function to get an empty va_list.
191: */
192: static void resolve_reference(private_settings_t *this, section_ref_t *ref,
193: array_t **sections, ...)
194: {
195: va_list args;
196:
197: va_start(args, sections);
198: find_sections(this, this->top, ref->name, args, sections);
199: va_end(args);
200: }
201:
202: /**
203: * Find all sections via a given key considering references, using buffered key,
204: * reusable buffer.
205: */
206: static void find_sections_buffered(private_settings_t *this, section_t *section,
207: char *start, char *key, va_list args,
208: char *buf, int len, bool ignore_refs,
209: array_t **sections)
210: {
211: section_t *found = NULL, *reference;
212: array_t *references;
213: section_ref_t *ref;
214: char *pos;
215: int i, j;
216:
217: if (!section)
218: {
219: return;
220: }
221: pos = strchr(key, '.');
222: if (pos)
223: {
224: *pos = '\0';
225: }
226: if (!print_key(buf, len, start, key, args))
227: {
228: return;
229: }
230: if (pos)
231: { /* restore so we can follow references */
232: *pos = '.';
233: }
234: if (!strlen(buf))
235: {
236: found = section;
237: }
238: else
239: {
240: array_bsearch(section->sections, buf, settings_section_find, &found);
241: }
242: if (found)
243: {
244: if (pos)
245: {
246: find_sections_buffered(this, found, start, pos+1, args, buf, len,
247: FALSE, sections);
248: }
249: else if (!has_section(*sections, found))
250: {
251: /* ignore if already added to avoid loops */
252: array_insert_create(sections, ARRAY_TAIL, found);
253: /* add all sections that are referenced here (also resolves
254: * references in parent sections of the referenced section) */
255: for (i = 0; i < array_count(found->references); i++)
256: {
257: array_get(found->references, i, &ref);
258: resolve_reference(this, ref, sections);
259: }
260: }
261: }
262: if (!ignore_refs && section != found && section->references)
263: {
264: /* find matching sub-sections relative to the referenced sections */
265: for (i = 0; i < array_count(section->references); i++)
266: {
267: array_get(section->references, i, &ref);
268: references = NULL;
269: resolve_reference(this, ref, &references);
270: for (j = 0; j < array_count(references); j++)
271: {
272: array_get(references, j, &reference);
273: /* ignore references in this referenced section, they were
274: * resolved via resolve_reference() */
275: find_sections_buffered(this, reference, start, key, args,
276: buf, len, TRUE, sections);
277: }
278: array_destroy(references);
279: }
280: }
281: }
282:
283: /**
284: * Ensure that the section with the given key exists (not thread-safe).
285: */
286: static section_t *ensure_section(private_settings_t *this, section_t *section,
287: const char *key, va_list args)
288: {
289: char buf[128], keybuf[512];
290:
291: if (snprintf(keybuf, sizeof(keybuf), "%s", key) >= sizeof(keybuf))
292: {
293: return NULL;
294: }
295: return find_section_buffered(section, keybuf, keybuf, args, buf,
296: sizeof(buf), TRUE);
297: }
298:
299: /**
300: * Find a section by a given key with resolved references (not thread-safe!).
301: * The array is allocated. NULL is returned if no sections are found.
302: */
303: static array_t *find_sections(private_settings_t *this, section_t *section,
304: char *key, va_list args, array_t **sections)
305: {
306: char buf[128], keybuf[512];
307:
308: if (snprintf(keybuf, sizeof(keybuf), "%s", key) >= sizeof(keybuf))
309: {
310: return NULL;
311: }
312: find_sections_buffered(this, section, keybuf, keybuf, args, buf,
313: sizeof(buf), FALSE, sections);
314: return *sections;
315: }
316:
317: /**
318: * Find the key/value pair for a key, using buffered key, reusable buffer
319: * There are two modes: 1. To find a key at an exact location and create the
320: * sections (and key/value pair) if necessary, don't pass an array for sections.
321: * 2. To find a key and follow references pass a pointer to an array to store
322: * visited sections. NULL is returned in this case if the key is not found.
323: */
324: static kv_t *find_value_buffered(private_settings_t *this, section_t *section,
325: char *start, char *key, va_list args,
326: char *buf, int len, bool ignore_refs,
327: array_t **sections)
328: {
329: section_t *found = NULL;
330: kv_t *kv = NULL;
331: section_ref_t *ref;
332: array_t *references;
333: char *pos;
334: int i, j;
335:
336: if (!section)
337: {
338: return NULL;
339: }
340: pos = strchr(key, '.');
341: if (pos)
342: {
343: *pos = '\0';
344: if (!print_key(buf, len, start, key, args))
345: {
346: return NULL;
347: }
348: /* restore so we can follow references */
349: *pos = '.';
350: if (!strlen(buf))
351: {
352: found = section;
353: }
354: else if (array_bsearch(section->sections, buf, settings_section_find,
355: &found) == -1)
356: {
357: if (!sections)
358: {
359: found = settings_section_create(strdup(buf));
360: settings_section_add(section, found, NULL);
361: }
362: }
363: if (found)
364: {
365: kv = find_value_buffered(this, found, start, pos+1, args, buf, len,
366: FALSE, sections);
367: }
368: }
369: else
370: {
371: if (sections)
372: {
373: array_insert_create(sections, ARRAY_TAIL, section);
374: }
375: if (!print_key(buf, len, start, key, args))
376: {
377: return NULL;
378: }
379: if (array_bsearch(section->kv, buf, settings_kv_find, &kv) == -1)
380: {
381: if (!sections)
382: {
383: kv = settings_kv_create(strdup(buf), NULL);
384: settings_kv_add(section, kv, NULL);
385: }
386: }
387: }
388: if (!kv && !ignore_refs && sections && section->references)
389: {
390: /* find key relative to the referenced sections */
391: for (i = 0; !kv && i < array_count(section->references); i++)
392: {
393: array_get(section->references, i, &ref);
394: references = NULL;
395: resolve_reference(this, ref, &references);
396: for (j = 0; !kv && j < array_count(references); j++)
397: {
398: array_get(references, j, &found);
399: /* ignore if already added to avoid loops */
400: if (!has_section(*sections, found))
401: {
402: /* ignore references in this referenced section, they were
403: * resolved via resolve_reference() */
404: kv = find_value_buffered(this, found, start, key, args,
405: buf, len, TRUE, sections);
406: }
407: }
408: array_destroy(references);
409: }
410: }
411: return kv;
412: }
413:
414: /**
415: * Remove the key/value pair for a key, using buffered key, reusable buffer
416: */
417: static void remove_value_buffered(private_settings_t *this, section_t *section,
418: char *start, char *key, va_list args,
419: char *buf, int len)
420: {
421: section_t *found = NULL;
422: kv_t *kv = NULL, *ordered = NULL;
423: char *pos;
424: int idx, i;
425:
426: if (!section)
427: {
428: return;
429: }
430: pos = strchr(key, '.');
431: if (pos)
432: {
433: *pos = '\0';
434: pos++;
435: }
436: if (!print_key(buf, len, start, key, args))
437: {
438: return;
439: }
440: if (!strlen(buf))
441: {
442: found = section;
443: }
444: if (pos)
445: {
446: if (array_bsearch(section->sections, buf, settings_section_find,
447: &found) != -1)
448: {
449: remove_value_buffered(this, found, start, pos, args, buf, len);
450: }
451: }
452: else
453: {
454: idx = array_bsearch(section->kv, buf, settings_kv_find, &kv);
455: if (idx != -1)
456: {
457: array_remove(section->kv, idx, NULL);
458: for (i = 0; i < array_count(section->kv_order); i++)
459: {
460: array_get(section->kv_order, i, &ordered);
461: if (kv == ordered)
462: {
463: array_remove(section->kv_order, i, NULL);
464: settings_kv_destroy(kv, this->contents);
465: break;
466: }
467: }
468: }
469: }
470: }
471:
472: /*
473: * Described in header
474: */
475: void settings_remove_value(settings_t *settings, char *key, ...)
476: {
477: private_settings_t *this = (private_settings_t*)settings;
478: char buf[128], keybuf[512];
479: va_list args;
480:
481: if (snprintf(keybuf, sizeof(keybuf), "%s", key) >= sizeof(keybuf))
482: {
483: return;
484: }
485: va_start(args, key);
486:
487: this->lock->read_lock(this->lock);
488: remove_value_buffered(this, this->top, keybuf, keybuf, args, buf,
489: sizeof(buf));
490: this->lock->unlock(this->lock);
491:
492: va_end(args);
493: }
494:
495: /**
496: * Find the string value for a key (thread-safe).
497: */
498: static char *find_value(private_settings_t *this, section_t *section,
499: char *key, va_list args)
500: {
501: char buf[128], keybuf[512], *value = NULL;
502: array_t *sections = NULL;
503: kv_t *kv;
504:
505: if (snprintf(keybuf, sizeof(keybuf), "%s", key) >= sizeof(keybuf))
506: {
507: return NULL;
508: }
509: this->lock->read_lock(this->lock);
510: kv = find_value_buffered(this, section, keybuf, keybuf, args,
511: buf, sizeof(buf), FALSE, §ions);
512: if (kv)
513: {
514: value = kv->value;
515: }
516: this->lock->unlock(this->lock);
517: array_destroy(sections);
518: return value;
519: }
520:
521: /**
522: * Set a value to a copy of the given string (thread-safe).
523: */
524: static void set_value(private_settings_t *this, section_t *section,
525: char *key, va_list args, char *value)
526: {
527: char buf[128], keybuf[512];
528: kv_t *kv;
529:
530: if (snprintf(keybuf, sizeof(keybuf), "%s", key) >= sizeof(keybuf))
531: {
532: return;
533: }
534: this->lock->write_lock(this->lock);
535: kv = find_value_buffered(this, section, keybuf, keybuf, args,
536: buf, sizeof(buf), FALSE, NULL);
537: if (kv)
538: {
539: settings_kv_set(kv, strdupnull(value), this->contents);
540: }
541: this->lock->unlock(this->lock);
542: }
543:
544: METHOD(settings_t, get_str, char*,
545: private_settings_t *this, char *key, char *def, ...)
546: {
547: char *value;
548: va_list args;
549:
550: va_start(args, def);
551: value = find_value(this, this->top, key, args);
552: va_end(args);
553: if (value)
554: {
555: return value;
556: }
557: return def;
558: }
559:
560: /**
561: * Described in header
562: */
563: inline bool settings_value_as_bool(char *value, bool def)
564: {
565: if (value)
566: {
567: if (strcaseeq(value, "1") ||
568: strcaseeq(value, "yes") ||
569: strcaseeq(value, "true") ||
570: strcaseeq(value, "enabled"))
571: {
572: return TRUE;
573: }
574: else if (strcaseeq(value, "0") ||
575: strcaseeq(value, "no") ||
576: strcaseeq(value, "false") ||
577: strcaseeq(value, "disabled"))
578: {
579: return FALSE;
580: }
581: }
582: return def;
583: }
584:
585: METHOD(settings_t, get_bool, bool,
586: private_settings_t *this, char *key, int def, ...)
587: {
588: char *value;
589: va_list args;
590:
591: /* we can't use bool for def due to this call */
592: va_start(args, def);
593: value = find_value(this, this->top, key, args);
594: va_end(args);
595: return settings_value_as_bool(value, def);
596: }
597:
598: /**
599: * Described in header
600: */
601: inline int settings_value_as_int(char *value, int def)
602: {
603: int intval;
604: char *end;
605: int base = 10;
606:
607: if (value)
608: {
609: errno = 0;
610: if (value[0] == '0' && value[1] == 'x')
611: { /* manually detect 0x prefix as we want to avoid octal encoding */
612: base = 16;
613: }
614: intval = strtoul(value, &end, base);
615: if (errno == 0 && *end == 0 && end != value)
616: {
617: return intval;
618: }
619: }
620: return def;
621: }
622:
623: METHOD(settings_t, get_int, int,
624: private_settings_t *this, char *key, int def, ...)
625: {
626: char *value;
627: va_list args;
628:
629: va_start(args, def);
630: value = find_value(this, this->top, key, args);
631: va_end(args);
632: return settings_value_as_int(value, def);
633: }
634:
635: /**
636: * Described in header
637: */
638: inline uint64_t settings_value_as_uint64(char *value, uint64_t def)
639: {
640: uint64_t intval;
641: char *end;
642: int base = 10;
643:
644: if (value)
645: {
646: errno = 0;
647: if (value[0] == '0' && value[1] == 'x')
648: { /* manually detect 0x prefix as we want to avoid octal encoding */
649: base = 16;
650: }
651: intval = strtoull(value, &end, base);
652: if (errno == 0 && *end == 0 && end != value)
653: {
654: return intval;
655: }
656: }
657: return def;
658: }
659:
660: /**
661: * Described in header
662: */
663: inline double settings_value_as_double(char *value, double def)
664: {
665: double dval;
666: char *end;
667:
668: if (value)
669: {
670: errno = 0;
671: dval = strtod(value, &end);
672: if (errno == 0 && *end == 0 && end != value)
673: {
674: return dval;
675: }
676: }
677: return def;
678: }
679:
680: METHOD(settings_t, get_double, double,
681: private_settings_t *this, char *key, double def, ...)
682: {
683: char *value;
684: va_list args;
685:
686: va_start(args, def);
687: value = find_value(this, this->top, key, args);
688: va_end(args);
689: return settings_value_as_double(value, def);
690: }
691:
692: /**
693: * Described in header
694: */
695: inline uint32_t settings_value_as_time(char *value, uint32_t def)
696: {
697: time_t val;
698:
699: if (timespan_from_string(value, NULL, &val))
700: {
701: return val;
702: }
703: return def;
704: }
705:
706: METHOD(settings_t, get_time, uint32_t,
707: private_settings_t *this, char *key, uint32_t def, ...)
708: {
709: char *value;
710: va_list args;
711:
712: va_start(args, def);
713: value = find_value(this, this->top, key, args);
714: va_end(args);
715: return settings_value_as_time(value, def);
716: }
717:
718: METHOD(settings_t, set_str, void,
719: private_settings_t *this, char *key, char *value, ...)
720: {
721: va_list args;
722: va_start(args, value);
723: set_value(this, this->top, key, args, value);
724: va_end(args);
725: }
726:
727: METHOD(settings_t, set_bool, void,
728: private_settings_t *this, char *key, int value, ...)
729: {
730: va_list args;
731: /* we can't use bool for value due to this call */
732: va_start(args, value);
733: set_value(this, this->top, key, args, value ? "1" : "0");
734: va_end(args);
735: }
736:
737: METHOD(settings_t, set_int, void,
738: private_settings_t *this, char *key, int value, ...)
739: {
740: char val[16];
741: va_list args;
742: va_start(args, value);
743: if (snprintf(val, sizeof(val), "%d", value) < sizeof(val))
744: {
745: set_value(this, this->top, key, args, val);
746: }
747: va_end(args);
748: }
749:
750: METHOD(settings_t, set_double, void,
751: private_settings_t *this, char *key, double value, ...)
752: {
753: char val[64];
754: va_list args;
755: va_start(args, value);
756: if (snprintf(val, sizeof(val), "%f", value) < sizeof(val))
757: {
758: set_value(this, this->top, key, args, val);
759: }
760: va_end(args);
761: }
762:
763: METHOD(settings_t, set_time, void,
764: private_settings_t *this, char *key, uint32_t value, ...)
765: {
766: char val[16];
767: va_list args;
768: va_start(args, value);
769: if (snprintf(val, sizeof(val), "%u", value) < sizeof(val))
770: {
771: set_value(this, this->top, key, args, val);
772: }
773: va_end(args);
774: }
775:
776: METHOD(settings_t, set_default_str, bool,
777: private_settings_t *this, char *key, char *value, ...)
778: {
779: char *old;
780: va_list args;
781:
782: va_start(args, value);
783: old = find_value(this, this->top, key, args);
784: va_end(args);
785:
786: if (!old)
787: {
788: va_start(args, value);
789: set_value(this, this->top, key, args, value);
790: va_end(args);
791: return TRUE;
792: }
793: return FALSE;
794: }
795:
796: /**
797: * Data for enumerators
798: */
799: typedef struct {
800: /** settings_t instance */
801: private_settings_t *settings;
802: /** sections to enumerate */
803: array_t *sections;
804: /** sections/keys that were already enumerated */
805: hashtable_t *seen;
806: } enumerator_data_t;
807:
808: CALLBACK(enumerator_destroy, void,
809: enumerator_data_t *this)
810: {
811: this->settings->lock->unlock(this->settings->lock);
812: this->seen->destroy(this->seen);
813: array_destroy(this->sections);
814: free(this);
815: }
816:
817: CALLBACK(section_filter, bool,
818: hashtable_t *seen, enumerator_t *orig, va_list args)
819: {
820: section_t *section;
821: char **out;
822:
823: VA_ARGS_VGET(args, out);
824:
825: while (orig->enumerate(orig, §ion))
826: {
827: if (seen->get(seen, section->name))
828: {
829: continue;
830: }
831: *out = section->name;
832: seen->put(seen, section->name, section->name);
833: return TRUE;
834: }
835: return FALSE;
836: }
837:
838: /**
839: * Enumerate sections of the given section
840: */
841: static enumerator_t *section_enumerator(section_t *section,
842: enumerator_data_t *data)
843: {
844: return enumerator_create_filter(
845: array_create_enumerator(section->sections_order),
846: section_filter, data->seen, NULL);
847: }
848:
849: METHOD(settings_t, create_section_enumerator, enumerator_t*,
850: private_settings_t *this, char *key, ...)
851: {
852: enumerator_data_t *data;
853: array_t *sections = NULL;
854: va_list args;
855:
856: this->lock->read_lock(this->lock);
857: va_start(args, key);
858: sections = find_sections(this, this->top, key, args, §ions);
859: va_end(args);
860:
861: if (!sections)
862: {
863: this->lock->unlock(this->lock);
864: return enumerator_create_empty();
865: }
866: INIT(data,
867: .settings = this,
868: .sections = sections,
869: .seen = hashtable_create(hashtable_hash_str, hashtable_equals_str, 8),
870: );
871: return enumerator_create_nested(array_create_enumerator(sections),
872: (void*)section_enumerator, data, enumerator_destroy);
873: }
874:
875: CALLBACK(kv_filter, bool,
876: hashtable_t *seen, enumerator_t *orig, va_list args)
877: {
878: kv_t *kv;
879: char **key, **value;
880:
881: VA_ARGS_VGET(args, key, value);
882:
883: while (orig->enumerate(orig, &kv))
884: {
885: if (seen->get(seen, kv->key))
886: {
887: continue;
888: }
889: seen->put(seen, kv->key, kv->key);
890: if (!kv->value)
891: {
892: continue;
893: }
894: *key = kv->key;
895: *value = kv->value;
896: return TRUE;
897: }
898: return FALSE;
899: }
900:
901: /**
902: * Enumerate key/value pairs of the given section
903: */
904: static enumerator_t *kv_enumerator(section_t *section, enumerator_data_t *data)
905: {
906: return enumerator_create_filter(array_create_enumerator(section->kv_order),
907: kv_filter, data->seen, NULL);
908: }
909:
910: METHOD(settings_t, create_key_value_enumerator, enumerator_t*,
911: private_settings_t *this, char *key, ...)
912: {
913: enumerator_data_t *data;
914: array_t *sections = NULL;
915: va_list args;
916:
917: this->lock->read_lock(this->lock);
918: va_start(args, key);
919: sections = find_sections(this, this->top, key, args, §ions);
920: va_end(args);
921:
922: if (!sections)
923: {
924: this->lock->unlock(this->lock);
925: return enumerator_create_empty();
926: }
927: INIT(data,
928: .settings = this,
929: .sections = sections,
930: .seen = hashtable_create(hashtable_hash_str, hashtable_equals_str, 8),
931: );
932: return enumerator_create_nested(array_create_enumerator(sections),
933: (void*)kv_enumerator, data, (void*)enumerator_destroy);
934: }
935:
936: METHOD(settings_t, add_fallback, void,
937: private_settings_t *this, const char *key, const char *fallback, ...)
938: {
939: section_t *section;
940: va_list args;
941: char buf[512];
942:
943: this->lock->write_lock(this->lock);
944: va_start(args, fallback);
945: section = ensure_section(this, this->top, key, args);
946: va_end(args);
947:
948: va_start(args, fallback);
949: if (section && vsnprintf(buf, sizeof(buf), fallback, args) < sizeof(buf))
950: {
951: settings_reference_add(section, strdup(buf), TRUE);
952: }
953: va_end(args);
954: this->lock->unlock(this->lock);
955: }
956:
957: /**
958: * Load settings from files matching the given file pattern or from a string.
959: * All files (even included ones) have to be loaded successfully.
960: */
961: static section_t *load_internal(char *pattern, bool string)
962: {
963: section_t *section;
964: bool loaded;
965:
966: if (pattern == NULL || !pattern[0])
967: {
968: return settings_section_create(NULL);
969: }
970:
971: section = settings_section_create(NULL);
972: loaded = string ? settings_parser_parse_string(section, pattern) :
973: settings_parser_parse_file(section, pattern);
974: if (!loaded)
975: {
976: settings_section_destroy(section, NULL);
977: section = NULL;
978: }
979: return section;
980: }
981:
982: /**
983: * Add sections and values in "section" relative to "parent".
984: * If merge is FALSE the contents of parent are replaced with the parsed
985: * contents, otherwise they are merged together.
986: *
987: * Releases the write lock and destroys the given section.
988: * If parent is NULL this is all that happens.
989: */
990: static bool extend_section(private_settings_t *this, section_t *parent,
991: section_t *section, bool merge)
992: {
993: if (parent)
994: {
995: settings_section_extend(parent, section, this->contents, !merge);
996: }
997: this->lock->unlock(this->lock);
998: settings_section_destroy(section, NULL);
999: return parent != NULL;
1000: }
1001:
1002: METHOD(settings_t, load_files, bool,
1003: private_settings_t *this, char *pattern, bool merge)
1004: {
1005: section_t *section;
1006:
1007: section = load_internal(pattern, FALSE);
1008: if (!section)
1009: {
1010: return FALSE;
1011: }
1012:
1013: this->lock->write_lock(this->lock);
1014: return extend_section(this, this->top, section, merge);
1015: }
1016:
1017: METHOD(settings_t, load_files_section, bool,
1018: private_settings_t *this, char *pattern, bool merge, char *key, ...)
1019: {
1020: section_t *section, *parent;
1021: va_list args;
1022:
1023: section = load_internal(pattern, FALSE);
1024: if (!section)
1025: {
1026: return FALSE;
1027: }
1028:
1029: this->lock->write_lock(this->lock);
1030:
1031: va_start(args, key);
1032: parent = ensure_section(this, this->top, key, args);
1033: va_end(args);
1034:
1035: return extend_section(this, parent, section, merge);
1036: }
1037:
1038: METHOD(settings_t, load_string, bool,
1039: private_settings_t *this, char *settings, bool merge)
1040: {
1041: section_t *section;
1042:
1043: section = load_internal(settings, TRUE);
1044: if (!section)
1045: {
1046: return FALSE;
1047: }
1048:
1049: this->lock->write_lock(this->lock);
1050: return extend_section(this, this->top, section, merge);
1051: }
1052:
1053: METHOD(settings_t, load_string_section, bool,
1054: private_settings_t *this, char *settings, bool merge, char *key, ...)
1055: {
1056: section_t *section, *parent;
1057: va_list args;
1058:
1059: section = load_internal(settings, TRUE);
1060: if (!section)
1061: {
1062: return FALSE;
1063: }
1064:
1065: this->lock->write_lock(this->lock);
1066:
1067: va_start(args, key);
1068: parent = ensure_section(this, this->top, key, args);
1069: va_end(args);
1070:
1071: return extend_section(this, parent, section, merge);
1072: }
1073:
1074: METHOD(settings_t, destroy, void,
1075: private_settings_t *this)
1076: {
1077: settings_section_destroy(this->top, NULL);
1078: array_destroy_function(this->contents, (void*)free, NULL);
1079: this->lock->destroy(this->lock);
1080: free(this);
1081: }
1082:
1083: static private_settings_t *settings_create_base()
1084: {
1085: private_settings_t *this;
1086:
1087: INIT(this,
1088: .public = {
1089: .get_str = _get_str,
1090: .get_int = _get_int,
1091: .get_double = _get_double,
1092: .get_time = _get_time,
1093: .get_bool = _get_bool,
1094: .set_str = _set_str,
1095: .set_int = _set_int,
1096: .set_double = _set_double,
1097: .set_time = _set_time,
1098: .set_bool = _set_bool,
1099: .set_default_str = _set_default_str,
1100: .create_section_enumerator = _create_section_enumerator,
1101: .create_key_value_enumerator = _create_key_value_enumerator,
1102: .add_fallback = _add_fallback,
1103: .load_files = _load_files,
1104: .load_files_section = _load_files_section,
1105: .load_string = _load_string,
1106: .load_string_section = _load_string_section,
1107: .destroy = _destroy,
1108: },
1109: .top = settings_section_create(NULL),
1110: .contents = array_create(0, 0),
1111: .lock = rwlock_create(RWLOCK_TYPE_DEFAULT),
1112: );
1113: return this;
1114: }
1115:
1116: /*
1117: * see header file
1118: */
1119: settings_t *settings_create(char *file)
1120: {
1121: private_settings_t *this = settings_create_base();
1122:
1123: load_files(this, file, FALSE);
1124:
1125: return &this->public;
1126: }
1127:
1128: /*
1129: * see header file
1130: */
1131: settings_t *settings_create_string(char *settings)
1132: {
1133: private_settings_t *this = settings_create_base();
1134:
1135: load_string(this, settings, FALSE);
1136:
1137: return &this->public;
1138: }