![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to settings_types.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_types.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: * 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 "settings_types.h"
17:
18: /*
19: * Described in header
20: */
21: kv_t *settings_kv_create(char *key, char *value)
22: {
23: kv_t *this;
24:
25: INIT(this,
26: .key = key,
27: .value = value,
28: );
29: return this;
30: }
31:
32: /*
33: * Described in header
34: */
35: void settings_kv_destroy(kv_t *this, array_t *contents)
36: {
37: free(this->key);
38: if (contents && this->value)
39: {
40: array_insert(contents, ARRAY_TAIL, this->value);
41: }
42: else
43: {
44: free(this->value);
45: }
46: free(this);
47: }
48:
49: /*
50: * Described in header
51: */
52: section_t *settings_section_create(char *name)
53: {
54: section_t *this;
55:
56: INIT(this,
57: .name = name,
58: );
59: return this;
60: }
61:
62: static void section_destroy(section_t *section, int idx, array_t *contents)
63: {
64: settings_section_destroy(section, contents);
65: }
66:
67: static void kv_destroy(kv_t *kv, int idx, array_t *contents)
68: {
69: settings_kv_destroy(kv, contents);
70: }
71:
72: static void ref_destroy(section_ref_t *ref, int idx, void *ctx)
73: {
74: free(ref->name);
75: free(ref);
76: }
77:
78: /*
79: * Described in header
80: */
81: void settings_section_destroy(section_t *this, array_t *contents)
82: {
83: array_destroy_function(this->sections, (void*)section_destroy, contents);
84: array_destroy(this->sections_order);
85: array_destroy_function(this->kv, (void*)kv_destroy, contents);
86: array_destroy(this->kv_order);
87: array_destroy_function(this->references, (void*)ref_destroy, NULL);
88: free(this->name);
89: free(this);
90: }
91:
92: /*
93: * Described in header
94: */
95: void settings_kv_set(kv_t *kv, char *value, array_t *contents)
96: {
97: if (value && kv->value && streq(value, kv->value))
98: { /* no update required */
99: free(value);
100: return;
101: }
102:
103: /* if the new value was shorter we could overwrite the existing one but that
104: * could lead to reads of partially updated values from other threads that
105: * have a pointer to the existing value, so we replace it anyway */
106: if (kv->value && contents)
107: {
108: array_insert(contents, ARRAY_TAIL, kv->value);
109: }
110: else
111: {
112: free(kv->value);
113: }
114: kv->value = value;
115: }
116:
117: /*
118: * Described in header
119: */
120: void settings_kv_add(section_t *section, kv_t *kv, array_t *contents)
121: {
122: kv_t *found;
123:
124: if (array_bsearch(section->kv, kv->key, settings_kv_find, &found) == -1)
125: {
126: array_insert_create(§ion->kv, ARRAY_TAIL, kv);
127: array_sort(section->kv, settings_kv_sort, NULL);
128: array_insert_create(§ion->kv_order, ARRAY_TAIL, kv);
129: }
130: else
131: {
132: settings_kv_set(found, kv->value, contents);
133: kv->value = NULL;
134: settings_kv_destroy(kv, NULL);
135: }
136: }
137:
138: /*
139: * Described in header
140: */
141: void settings_reference_add(section_t *section, char *name, bool permanent)
142: {
143: section_ref_t *ref;
144: int i;
145:
146: for (i = 0; i < array_count(section->references); i++)
147: {
148: array_get(section->references, i, &ref);
149: if (ref->permanent && !permanent)
150: { /* add it before any permanent references */
151: break;
152: }
153: if (ref->permanent == permanent && streq(name, ref->name))
154: {
155: free(name);
156: return;
157: }
158: }
159:
160: INIT(ref,
161: .name = name,
162: .permanent = permanent,
163: );
164: array_insert_create(§ion->references, i, ref);
165: }
166:
167: /*
168: * Add a section to the given parent, optionally remove settings/subsections
169: * not found when extending an existing section
170: */
171: static void add_section(section_t *parent, section_t *section,
172: array_t *contents, bool purge)
173: {
174: section_t *found;
175:
176: if (array_bsearch(parent->sections, section->name, settings_section_find,
177: &found) == -1)
178: {
179: array_insert_create(&parent->sections, ARRAY_TAIL, section);
180: array_sort(parent->sections, settings_section_sort, NULL);
181: array_insert_create(&parent->sections_order, ARRAY_TAIL, section);
182: }
183: else
184: {
185: settings_section_extend(found, section, contents, purge);
186: settings_section_destroy(section, contents);
187: }
188: }
189:
190: /*
191: * Described in header
192: */
193: void settings_section_add(section_t *parent, section_t *section,
194: array_t *contents)
195: {
196: add_section(parent, section, contents, FALSE);
197: }
198:
199: /**
200: * Purge contents of a section, returns TRUE if section can be safely removed.
201: */
202: static bool section_purge(section_t *this, array_t *contents)
203: {
204: section_t *current;
205: section_ref_t *ref;
206: int i, idx;
207:
208: array_destroy_function(this->kv, (void*)kv_destroy, contents);
209: this->kv = NULL;
210: array_destroy(this->kv_order);
211: this->kv_order = NULL;
212: /* remove non-permanent references */
213: for (i = array_count(this->references) - 1; i >= 0; i--)
214: {
215: array_get(this->references, i, &ref);
216: if (!ref->permanent)
217: {
218: array_remove(this->references, i, NULL);
219: ref_destroy(ref, 0, NULL);
220: }
221: }
222: if (!array_count(this->references))
223: {
224: array_destroy(this->references);
225: this->references = NULL;
226: }
227: for (i = array_count(this->sections_order) - 1; i >= 0; i--)
228: {
229: array_get(this->sections_order, i, ¤t);
230: if (section_purge(current, contents))
231: {
232: array_remove(this->sections_order, i, NULL);
233: idx = array_bsearch(this->sections, current->name,
234: settings_section_find, NULL);
235: array_remove(this->sections, idx, NULL);
236: settings_section_destroy(current, contents);
237: }
238: }
239: /* we ensure sections configured with permanent references (or having any
240: * such subsections) are not removed */
241: return !this->references && !array_count(this->sections);
242: }
243:
244: /*
245: * Described in header
246: */
247: void settings_section_extend(section_t *base, section_t *extension,
248: array_t *contents, bool purge)
249: {
250: enumerator_t *enumerator;
251: section_t *section;
252: section_ref_t *ref;
253: kv_t *kv;
254: array_t *sections = NULL, *kvs = NULL;
255: int idx;
256:
257: if (purge)
258: { /* remove sections, settings in base not found in extension, the others
259: * are removed too (from the _order list) so they can be inserted in the
260: * order found in extension, non-permanent references are removed */
261: enumerator = array_create_enumerator(base->sections_order);
262: while (enumerator->enumerate(enumerator, (void**)§ion))
263: {
264: if (array_bsearch(extension->sections, section->name,
265: settings_section_find, NULL) == -1)
266: {
267: idx = array_bsearch(base->sections, section->name,
268: settings_section_find, NULL);
269: if (section_purge(section, contents))
270: { /* only remove them if we can purge them */
271: array_remove(base->sections, idx, NULL);
272: array_remove_at(base->sections_order, enumerator);
273: settings_section_destroy(section, contents);
274: }
275: }
276: else
277: {
278: array_remove_at(base->sections_order, enumerator);
279: array_insert_create(§ions, ARRAY_TAIL, section);
280: array_sort(sections, settings_section_sort, NULL);
281: }
282: }
283: enumerator->destroy(enumerator);
284:
285: while (array_remove(base->kv_order, 0, &kv))
286: {
287: if (array_bsearch(extension->kv, kv->key, settings_kv_find,
288: NULL) == -1)
289: {
290: idx = array_bsearch(base->kv, kv->key, settings_kv_find, NULL);
291: array_remove(base->kv, idx, NULL);
292: settings_kv_destroy(kv, contents);
293: }
294: else
295: {
296: array_insert_create(&kvs, ARRAY_TAIL, kv);
297: array_sort(kvs, settings_kv_sort, NULL);
298: }
299: }
300:
301: enumerator = array_create_enumerator(base->references);
302: while (enumerator->enumerate(enumerator, (void**)&ref))
303: {
304: if (ref->permanent)
305: { /* permanent references are ignored */
306: continue;
307: }
308: array_remove_at(base->references, enumerator);
309: ref_destroy(ref, 0, NULL);
310: }
311: enumerator->destroy(enumerator);
312: }
313:
314: while (array_remove(extension->sections_order, 0, §ion))
315: {
316: idx = array_bsearch(sections, section->name,
317: settings_section_find, NULL);
318: if (idx != -1)
319: {
320: section_t *existing;
321:
322: array_remove(sections, idx, &existing);
323: array_insert(base->sections_order, ARRAY_TAIL, existing);
324: }
325: idx = array_bsearch(extension->sections, section->name,
326: settings_section_find, NULL);
327: array_remove(extension->sections, idx, NULL);
328: add_section(base, section, contents, purge);
329: }
330:
331: while (array_remove(extension->kv_order, 0, &kv))
332: {
333: idx = array_bsearch(kvs, kv->key, settings_kv_find, NULL);
334: if (idx != -1)
335: {
336: kv_t *existing;
337:
338: array_remove(kvs, idx, &existing);
339: array_insert(base->kv_order, ARRAY_TAIL, existing);
340: }
341: idx = array_bsearch(extension->kv, kv->key, settings_kv_find, NULL);
342: array_remove(extension->kv, idx, NULL);
343: settings_kv_add(base, kv, contents);
344: }
345:
346: while (array_remove(extension->references, 0, &ref))
347: {
348: if (ref->permanent)
349: { /* ignore permanent references in the extension */
350: continue;
351: }
352: settings_reference_add(base, strdup(ref->name), FALSE);
353: ref_destroy(ref, 0, NULL);
354: }
355: array_destroy(sections);
356: array_destroy(kvs);
357: }
358:
359: /*
360: * Described in header
361: */
362: int settings_section_find(const void *a, const void *b)
363: {
364: const char *key = a;
365: const section_t *item = b;
366: return strcmp(key, item->name);
367: }
368:
369: /*
370: * Described in header
371: */
372: int settings_section_sort(const void *a, const void *b, void *user)
373: {
374: const section_t *sa = a, *sb = b;
375: return strcmp(sa->name, sb->name);
376: }
377:
378: /*
379: * Described in header
380: */
381: int settings_kv_find(const void *a, const void *b)
382: {
383: const char *key = a;
384: const kv_t *item = b;
385: return strcmp(key, item->key);
386: }
387:
388: /*
389: * Described in header
390: */
391: int settings_kv_sort(const void *a, const void *b, void *user)
392: {
393: const kv_t *kva = a, *kvb = b;
394: return strcmp(kva->key, kvb->key);
395: }