File:
[ELWIX - Embedded LightWeight unIX -] /
libaitcfg /
src /
parse.c
Revision
1.14:
download - view:
text,
annotated -
select for diffs -
revision graph
Thu Jan 30 08:30:47 2014 UTC (10 years, 3 months ago) by
misho
Branches:
MAIN
CVS tags:
cfg7_7,
cfg7_6,
cfg7_5,
cfg7_4,
HEAD,
CFG7_6,
CFG7_5,
CFG7_4,
CFG7_3
version 7.3
1: /*************************************************************************
2: * (C) 2008 AITNET ltd - Sofia/Bulgaria - <misho@aitbg.com>
3: * by Michael Pounov <misho@openbsd-bg.org>
4: *
5: * $Author: misho $
6: * $Id: parse.c,v 1.14 2014/01/30 08:30:47 misho Exp $
7: *
8: **************************************************************************
9: The ELWIX and AITNET software is distributed under the following
10: terms:
11:
12: All of the documentation and software included in the ELWIX and AITNET
13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
14:
15: Copyright 2004 - 2014
16: by Michael Pounov <misho@elwix.org>. All rights reserved.
17:
18: Redistribution and use in source and binary forms, with or without
19: modification, are permitted provided that the following conditions
20: are met:
21: 1. Redistributions of source code must retain the above copyright
22: notice, this list of conditions and the following disclaimer.
23: 2. Redistributions in binary form must reproduce the above copyright
24: notice, this list of conditions and the following disclaimer in the
25: documentation and/or other materials provided with the distribution.
26: 3. All advertising materials mentioning features or use of this software
27: must display the following acknowledgement:
28: This product includes software developed by Michael Pounov <misho@elwix.org>
29: ELWIX - Embedded LightWeight unIX and its contributors.
30: 4. Neither the name of AITNET nor the names of its contributors
31: may be used to endorse or promote products derived from this software
32: without specific prior written permission.
33:
34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
37: ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
44: SUCH DAMAGE.
45: */
46: #include "global.h"
47:
48:
49: /*
50: * cfgReadConfig() - Read file and add new item at config root
51: *
52: * @f = File resource
53: * @cfg = Config root
54: * return: -1 error or 0 ok
55: */
56: int
57: cfgReadConfig(FILE *f, cfg_root_t * __restrict cfg)
58: {
59: char line[BUFSIZ];
60: struct tagCfg *av = NULL;
61: int flg = 0;
62: char *psAttr, *psVal, szSection[STRSIZ] = { 0 };
63:
64: if (!f || !cfg) {
65: cfg_SetErr(EINVAL, "Invalid parameter(s)");
66: return -1;
67: }
68:
69: while (!feof(f)) {
70: memset(line, 0, sizeof line);
71: fgets(line, sizeof line - 1, f);
72: #ifdef SUPPORT_USER_EOF
73: /* check for user end-of-file */
74: if (line[0] == '.' && line[1] == '\n')
75: break;
76: #endif
77: if (!(psAttr = strpbrk(line, "\r\n"))) {
78: /* skip line, too long */
79: continue;
80: } else {
81: *psAttr = 0;
82: str_Trim(line);
83: }
84:
85: if (flg) {
86: /* continues line */
87: if (!av)
88: continue;
89: else
90: psAttr = line + strlen(line) - 1;
91: if (*psAttr == '\\')
92: *psAttr = 0;
93: else
94: flg = 0;
95: /* concat line to value */
96: AIT_SET_STRCAT(&av->cfg_val, line);
97: if (!flg && AIT_ADDR(&av->cfg_val))
98: str_Unquot((char*) AIT_GET_STR(&av->cfg_val));
99: continue;
100: }
101:
102: /* *NEW PAIR* alloc new pair element */
103: av = e_malloc(sizeof(struct tagCfg));
104: if (!av) {
105: cfg_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
106: return -1;
107: } else {
108: memset(av, 0, sizeof(struct tagCfg));
109: CFG_RC_LOCK(cfg);
110: TAILQ_INSERT_TAIL(cfg, av, cfg_next);
111: CFG_RC_UNLOCK(cfg);
112: }
113:
114: /* check for continues line */
115: psAttr = line + (*line ? strlen(line) : 1) - 1;
116: if (*psAttr == '\\') {
117: *psAttr = 0;
118: flg = 1;
119: }
120:
121: /* check for comment or empty line */
122: if (!*line || *line == '#' || *line == ';') {
123: AIT_SET_STR(&av->cfg_val, line);
124: continue;
125: }
126: /* section */
127: if (*line == '[') {
128: psAttr = line + strlen(line) - 1;
129: if (*psAttr == ']') {
130: *psAttr = 0;
131: flg = 0;
132: strlcpy(szSection, line + 1, sizeof szSection);
133: AIT_SET_STR(&av->cfg_sec, line);
134: } else
135: EDEBUG(7, "Ignore section '%s' ... not found ']'", line);
136: continue;
137: }
138: /* parse pair */
139: if (!(psAttr = strchr(line, '='))) {
140: AIT_SET_STR(&av->cfg_val, line);
141: EDEBUG(7, "Ignore a/v '%s' ... not found '='", line);
142: continue;
143: } else {
144: *psAttr = 0;
145: psVal = psAttr + 1;
146: psAttr = line;
147: }
148:
149: /* if exists, added section name to element */
150: if (*szSection) {
151: AIT_SET_STR(&av->cfg_sec, szSection);
152: AIT_KEY(&av->cfg_sec) = crcFletcher16(AIT_GET_LIKE(&av->cfg_sec, u_short*),
153: E_ALIGN(AIT_LEN(&av->cfg_sec) - 1, 2) / 2);
154: }
155:
156: str_RTrim(psAttr);
157: str_LTrim(psVal);
158: if (!flg)
159: str_Unquot(psVal);
160: AIT_SET_STR(&av->cfg_val, psVal);
161: AIT_SET_STR(&av->cfg_attr, psAttr);
162: AIT_KEY(&av->cfg_attr) = crcFletcher16(AIT_GET_LIKE(&av->cfg_attr, u_short*),
163: E_ALIGN(AIT_LEN(&av->cfg_attr) - 1, 2) / 2);
164:
165: CFG_RC_LOCK(cfg);
166: RB_INSERT(tagRC, cfg, av);
167: CFG_RC_UNLOCK(cfg);
168: }
169:
170: return 0;
171: }
172:
173: /*
174: * cfgWriteConfig() - Write config from memory
175: *
176: * @f = File handle
177: * @cfg = Config root
178: * @whitespace = Additional whitespace characters to file
179: * return: -1 error or 0 ok
180: */
181: int
182: cfgWriteConfig(FILE *f, cfg_root_t * __restrict cfg, int whitespace)
183: {
184: struct tagCfg *av;
185: time_t tim;
186: char line[BUFSIZ] = { 0 }, szSection[STRSIZ] = { [0 ... STRSIZ - 1] = 0 };
187:
188: if (!f || !cfg) {
189: cfg_SetErr(EINVAL, "Invalid parameter(s)");
190: return -1;
191: }
192:
193: if (whitespace) {
194: time(&tim);
195: memset(line, 0, sizeof line);
196: strftime(line, sizeof line, "(UTC) %Y-%m-%d %H:%M:%S", gmtime(&tim));
197: cfg_Write(f, "## Config auto-generated at :: %s ##\n", line);
198: }
199:
200: CFG_RC_LOCK(cfg);
201: RB_FOREACH(av, tagRC, cfg) {
202: /* empty lines or comment */
203: if (AIT_ISEMPTY(&av->cfg_attr)) {
204: if (AIT_ISEMPTY(&av->cfg_val))
205: continue;
206: strlcpy(line, AIT_GET_STR(&av->cfg_val), sizeof line);
207: goto skip_sec;
208: }
209:
210: /* section [] */
211: if (!AIT_ISEMPTY(&av->cfg_sec) && AIT_ADDR(&av->cfg_sec) &&
212: strcmp(AIT_GET_STRZ(&av->cfg_sec), szSection)) {
213: strlcpy(szSection, AIT_GET_STR(&av->cfg_sec), sizeof szSection);
214: if (!cfg_Write(f, "\n[%s]\n", AIT_GET_STR(&av->cfg_sec))) {
215: LOGERR;
216: CFG_RC_UNLOCK(cfg);
217: return -1;
218: }
219: } else if (AIT_ISEMPTY(&av->cfg_sec) && *szSection) {
220: memset(szSection, 0, sizeof szSection);
221: if (!cfg_Write(f, "\n[]\n")) {
222: LOGERR;
223: CFG_RC_UNLOCK(cfg);
224: return -1;
225: }
226: }
227:
228: /* build line */
229: memset(line, 0, sizeof line);
230: if (!AIT_ISEMPTY(&av->cfg_attr) && AIT_TYPE(&av->cfg_attr) == string) {
231: strlcpy(line, AIT_GET_STRZ(&av->cfg_attr), sizeof line);
232: if (whitespace)
233: strlcat(line, " = ", sizeof line);
234: else
235: strlcat(line, "=", sizeof line);
236: }
237: if (!AIT_ISEMPTY(&av->cfg_val) && AIT_TYPE(&av->cfg_val) == string)
238: strlcat(line, AIT_GET_STRZ(&av->cfg_val), sizeof line);
239: skip_sec:
240: /* write */
241: if (!cfg_Write(f, "%s\n", line)) {
242: LOGERR;
243: CFG_RC_UNLOCK(cfg);
244: return -1;
245: }
246: }
247: CFG_RC_UNLOCK(cfg);
248:
249: if (whitespace) {
250: time(&tim);
251: memset(line, 0, sizeof line);
252: strftime(line, sizeof line, "(UTC) %Y-%m-%d %H:%M:%S", gmtime(&tim));
253: cfg_Write(f, "\n## Config was saved at :: %s ##\n", line);
254: }
255:
256: return 0;
257: }
258:
259: /*
260: * cfgConcatConfig() - Concat two configs into one
261: *
262: * @cfg = Config root
263: * @add_cfg = Concated config will be destroy after merge
264: * return: -1 error or 0 ok
265: */
266: int
267: cfgConcatConfig(cfg_root_t * __restrict cfg, cfg_root_t * __restrict add_cfg)
268: {
269: struct tagCfg *item;
270:
271: if (!cfg || !add_cfg)
272: return -1;
273:
274: CFG_RC_LOCK(add_cfg);
275: CFG_RC_LOCK(cfg);
276:
277: /* concat lists & red-black trees */
278: TAILQ_FOREACH(item, add_cfg, cfg_next) {
279: TAILQ_INSERT_TAIL(cfg, item, cfg_next);
280: RB_INSERT(tagRC, cfg, item);
281: }
282:
283: CFG_RC_UNLOCK(cfg);
284:
285: TAILQ_INIT(add_cfg);
286: RB_INIT(add_cfg);
287: CFG_RC_UNLOCK(add_cfg);
288: pthread_mutex_destroy(&add_cfg->rc_mtx);
289: return 0;
290: }
291:
292: /*
293: * cfgMergeConfig() - Marge two list in one cfg and destroy add_cfg
294: *
295: * @cfg = Config root of main list
296: * @add_cfg = Merged config will be destroy after merge
297: * return: -1 error or 0 ok
298: */
299: int
300: cfgMergeConfig(cfg_root_t * __restrict cfg, cfg_root_t * __restrict add_cfg)
301: {
302: struct tagCfg *item, *merge, *add_next, *next;
303: int flg;
304:
305: if (!cfg || !add_cfg)
306: return -1;
307:
308: CFG_RC_LOCK(add_cfg);
309: CFG_RC_LOCK(cfg);
310:
311: /* merge lists */
312: TAILQ_FOREACH_SAFE(item, add_cfg, cfg_next, add_next) {
313: flg = 0;
314: TAILQ_FOREACH_SAFE(merge, cfg, cfg_next, next) {
315: if (AIT_ISEMPTY(&merge->cfg_sec) && AIT_ISEMPTY(&item->cfg_sec)) {
316: flg = 1;
317: break;
318: }
319: if (!AIT_ISEMPTY(&merge->cfg_sec) && !AIT_ISEMPTY(&item->cfg_sec) &&
320: AIT_ADDR(&merge->cfg_sec) && AIT_ADDR(&item->cfg_sec) &&
321: !strcmp(AIT_GET_STR(&merge->cfg_sec), AIT_GET_STR(&item->cfg_sec))) {
322: flg = 1;
323: break;
324: }
325: }
326:
327: if (!flg)
328: TAILQ_INSERT_TAIL(cfg, item, cfg_next);
329: else
330: TAILQ_INSERT_AFTER(cfg, merge, item, cfg_next);
331: RB_INSERT(tagRC, cfg, item);
332: }
333:
334: CFG_RC_UNLOCK(cfg);
335:
336: TAILQ_INIT(add_cfg);
337: RB_INIT(add_cfg);
338: CFG_RC_UNLOCK(add_cfg);
339: pthread_mutex_destroy(&add_cfg->rc_mtx);
340: return 0;
341: }
342:
343: /*
344: * cfgReadLines() - Read custom lines and add new item at config root
345: *
346: * @f = File resource
347: * @delim = Custom delimiter, if =NULL default is '='
348: * @end = Custom user end of file, if =NULL default is EOF
349: * @cfg = Config root
350: * return: -1 error or 0 ok
351: */
352: int
353: cfgReadLines(FILE *f, const char *delim, const char *end, cfg_root_t * __restrict cfg)
354: {
355: char line[BUFSIZ];
356: struct tagCfg *d, *av = NULL;
357: char *p, *psSec, *psAttr, *psVal;
358:
359: if (!cfg)
360: return -1;
361: if (!delim)
362: delim = ATR_LINES_DELIM;
363:
364: while (!feof(f)) {
365: psSec = psAttr = psVal = NULL;
366: memset(line, 0, sizeof line);
367: fgets(line, sizeof line - 1, f);
368: /* check for user end-of-file */
369: if (strspn(line, end))
370: break;
371:
372: if (!(psAttr = strpbrk(line, "\r\n"))) {
373: /* skip line, too long */
374: continue;
375: } else {
376: *psAttr = 0;
377: str_Trim(line);
378: if (!*line)
379: continue;
380: }
381:
382: if (!av_MakeExt(line, delim, &p, &psVal))
383: continue;
384: else {
385: str_RTrim(p);
386: str_LTrim(psVal);
387: }
388: if (!av_MakeExt(p, SEC_LINES_DELIM, &psSec, &psAttr))
389: psAttr = p;
390:
391: /* *NEW PAIR* alloc new pair element */
392: av = e_malloc(sizeof(struct tagCfg));
393: if (!av) {
394: LOGERR;
395: return -1;
396: } else
397: memset(av, 0, sizeof(struct tagCfg));
398:
399: if (psSec) {
400: AIT_SET_STR(&av->cfg_sec, psSec);
401: AIT_KEY(&av->cfg_sec) = crcFletcher16(AIT_GET_LIKE(&av->cfg_sec, u_short*),
402: E_ALIGN(AIT_LEN(&av->cfg_sec) - 1, 2) / 2);
403: }
404: if (psVal)
405: AIT_SET_STR(&av->cfg_val, psVal);
406: AIT_SET_STR(&av->cfg_attr, psAttr);
407: AIT_KEY(&av->cfg_attr) = crcFletcher16(AIT_GET_LIKE(&av->cfg_attr, u_short*),
408: E_ALIGN(AIT_LEN(&av->cfg_attr) - 1, 2) / 2);
409:
410: CFG_RC_LOCK(cfg);
411: /* find & delete duplicates */
412: if ((d = RB_FIND(tagRC, cfg, av))) {
413: RB_REMOVE(tagRC, cfg, d);
414: TAILQ_REMOVE(cfg, d, cfg_next);
415:
416: AIT_FREE_VAL(&d->cfg_val);
417: AIT_FREE_VAL(&d->cfg_attr);
418: AIT_FREE_VAL(&d->cfg_sec);
419: e_free(d);
420: }
421:
422: TAILQ_INSERT_TAIL(cfg, av, cfg_next);
423: RB_INSERT(tagRC, cfg, av);
424: CFG_RC_UNLOCK(cfg);
425: }
426:
427: return 0;
428: }
429:
430: /*
431: * cfgWriteLines() - Write custom lines and export data to variable
432: *
433: * @f = File resource
434: * @delim = Custom delimiter, if =NULL default is '='
435: * @eol = End of line string, if =NULL default is "\n"
436: * @section = Export only section, if =NULL default is all
437: * @cfg = Config root
438: * return: =NULL error or !=NULL exported data, must be free after use with ait_freeVar()
439: */
440: ait_val_t *
441: cfgWriteLines(FILE *f, const char *delim, const char *eol, const char *section, cfg_root_t * __restrict cfg)
442: {
443: ait_val_t *v = NULL;
444: struct tagCfg *av;
445:
446: if (!cfg)
447: return NULL;
448: if (!delim)
449: delim = ATR_LINES_DELIM;
450: if (!eol)
451: eol = EOL_LINES_DELIM;
452: if (!(v = ait_allocVar())) {
453: cfg_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
454: return NULL;
455: } else
456: AIT_INIT_VAL2(v, string);
457:
458: TAILQ_FOREACH(av, cfg, cfg_next) {
459: if (AIT_ISEMPTY(&av->cfg_attr))
460: continue;
461: if (section) {
462: if (!AIT_ISEMPTY(&av->cfg_sec) && *section)
463: continue;
464: if (strcmp(section, AIT_GET_STRZ(&av->cfg_sec)))
465: continue;
466: }
467:
468: if (!AIT_ISEMPTY(&av->cfg_sec)) {
469: AIT_SET_STRCAT(v, AIT_GET_STR(&av->cfg_sec));
470: AIT_SET_STRCAT(v, SEC_LINES_DELIM);
471: }
472: AIT_SET_STRCAT(v, AIT_GET_STR(&av->cfg_attr));
473: AIT_SET_STRCAT(v, delim);
474: if (!AIT_ISEMPTY(&av->cfg_val))
475: AIT_SET_STRCAT(v, AIT_GET_STR(&av->cfg_val));
476: AIT_SET_STRCAT(v, eol);
477: }
478:
479: if (f)
480: fputs(AIT_GET_STR(v), f);
481: return v;
482: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to parse.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / libaitcfg / src