--- libaitcfg/src/parse.c 2010/03/22 15:15:48 1.5 +++ libaitcfg/src/parse.c 2023/01/23 23:27:26 1.21 @@ -3,311 +3,602 @@ * by Michael Pounov * * $Author: misho $ -* $Id: parse.c,v 1.5 2010/03/22 15:15:48 misho Exp $ +* $Id: parse.c,v 1.21 2023/01/23 23:27:26 misho Exp $ * -*************************************************************************/ -#include "global.h" -#include "aitcfg.h" -#include "tools.h" +************************************************************************** +The ELWIX and AITNET software is distributed under the following +terms: +All of the documentation and software included in the ELWIX and AITNET +Releases is copyrighted by ELWIX - Sofia/Bulgaria -// cfgDbg() Debug/Log operation -static inline int cfgDbg(FILE *f, char *fmt, ...) -{ - int ret = 0; - va_list lst; +Copyright 2004 - 2023 + by Michael Pounov . All rights reserved. - va_start(lst, fmt); - ret = vfprintf(f, fmt, lst); - va_end(lst); +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. All advertising materials mentioning features or use of this software + must display the following acknowledgement: +This product includes software developed by Michael Pounov +ELWIX - Embedded LightWeight unIX and its contributors. +4. Neither the name of AITNET nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. - return ret; -} +THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +SUCH DAMAGE. +*/ +#include "global.h" + /* - * InvertQueue() InvertQueue order //{cfg} list of elements for revert - * @cfg = Head list element for revert -*/ -static inline void InvertQueue(sl_config * __restrict cfg) + * cfgReadConfig() - Read file and add new item at config root + * + * @f = File resource + * @cfg = Config root + * return: -1 error or 0 ok + */ +int +cfgReadConfig(FILE *f, cfg_root_t * __restrict cfg) { - struct tagPair *item, *next, *prev = NULL; + char line[BUFSIZ], origin[BUFSIZ], chkattr[STRSIZ]; + struct tagCfg *av = NULL; + int flg = 0; + char *psAttr, *psVal, szSection[STRSIZ] = { 0 }; + FILE *ff; - for (item = cfg->slh_first; item; item = next) { - next = item->sle_next; - item->sle_next = prev; - prev = item; + if (!f || !cfg) { + cfg_SetErr(EINVAL, "Invalid parameter(s)"); + return -1; } - cfg->slh_first = prev; + + while (!feof(f)) { + memset(line, 0, sizeof line); + if (!fgets(line, sizeof(line) - 1, f)) + break; +#ifdef SUPPORT_USER_EOF + /* check for user end-of-file */ + if (line[0] == '.' && line[1] == '\n') + break; +#endif + if (!(psAttr = strpbrk(line, "\r\n"))) { + /* skip line, too long */ + continue; + } else { + *psAttr = 0; + strlcpy(origin, line, sizeof origin); + str_Trim(line); + } + + if (flg) { + /* continues line */ + if (!av) + continue; + else + psAttr = line + strlen(line) - 1; + if (*psAttr == '\\') + *psAttr = 0; + else + flg = 0; + /* concat line to value */ + AIT_SET_STRCAT(&av->cfg_val, line); + if (!flg && AIT_ADDR(&av->cfg_val)) + av->cfg_quoted += str_Unquot((char*) AIT_GET_STR(&av->cfg_val)); + + /* read include file */ + if (!flg && AIT_ADDR(&av->cfg_val) && + *AIT_GET_STR(&av->cfg_attr) == '%' && + !strcmp(AIT_GET_STR(&av->cfg_attr), "%include")) { + ff = fopen(AIT_GET_STR(&av->cfg_val), "r"); + if (ff) { + cfgReadConfig(ff, cfg); + fclose(ff); + } else + EDEBUG(ELWIX_DEBUG_LOG, "Error:: Can't open %s file", + AIT_GET_STR(&av->cfg_val)); + } + continue; + } + + /* check for duplicated element */ + if (*line != '#' && *line != ';' && *line != '/' && *line != '%' && + (psAttr = strchr(line, '='))) { + strncpy(chkattr, line, psAttr - line); + chkattr[psAttr - line] = 0; + str_RTrim(chkattr); + if (cfg_findAttribute(cfg, szSection, chkattr)) + cfg_unsetAttribute(cfg, szSection, chkattr); + } + + /* *NEW PAIR* alloc new pair element */ + av = e_malloc(sizeof(struct tagCfg)); + if (!av) { + cfg_SetErr(elwix_GetErrno(), "%s", elwix_GetError()); + return -1; + } else { + memset(av, 0, sizeof(struct tagCfg)); + CFG_RC_LOCK(cfg); + TAILQ_INSERT_TAIL(cfg, av, cfg_next); + CFG_RC_UNLOCK(cfg); + } + + /* check for comment or empty line */ + if (!*line || *line == '#' || *line == ';') { + AIT_SET_STR(&av->cfg_val, line); + continue; + } + + /* check for continues line */ + psAttr = line + (*line ? strlen(line) : 1) - 1; + if (*psAttr == '\\') { + *psAttr = 0; + flg = 1; + } + + /* section */ + if (*line == '[') { + psAttr = line + strlen(line) - 1; + if (*psAttr == ']') { + *psAttr = 0; + flg = 0; + strlcpy(szSection, line + 1, sizeof szSection); + AIT_SET_STR(&av->cfg_sec, line); + } else + EDEBUG(ELWIX_DEBUG_LOG, "Ignore section '%s' ... not found ']'", line); + continue; + } + /* parse pair */ + if (!(psAttr = strchr(line, '='))) { + AIT_SET_STR(&av->cfg_val, origin); + EDEBUG(ELWIX_DEBUG_LOG, "Ignore a/v '%s' ... not found '='", line); + continue; + } else { + *psAttr = 0; + psVal = psAttr + 1; + psAttr = line; + } + + /* if exists, added section name to element */ + if (*szSection) { + AIT_SET_STR(&av->cfg_sec, szSection); + AIT_KEY(&av->cfg_sec) = crcFletcher16(AIT_GET_LIKE(&av->cfg_sec, u_short*), + E_ALIGN(AIT_LEN(&av->cfg_sec) - 1, 2) / 2); + } + + str_RTrim(psAttr); + str_LTrim(psVal); + if (!flg) + av->cfg_quoted += str_Unquot(psVal); + AIT_SET_STR(&av->cfg_val, psVal); + AIT_SET_STR(&av->cfg_attr, psAttr); + AIT_KEY(&av->cfg_attr) = crcFletcher16(AIT_GET_LIKE(&av->cfg_attr, u_short*), + E_ALIGN(AIT_LEN(&av->cfg_attr) - 1, 2) / 2); + + CFG_RC_LOCK(cfg); + RB_INSERT(tagRC, cfg, av); + CFG_RC_UNLOCK(cfg); + + /* read include file */ + if (!flg && *AIT_GET_STR(&av->cfg_attr) == '%' && + !strcmp(AIT_GET_STR(&av->cfg_attr), "%include")) { + ff = fopen(AIT_GET_STR(&av->cfg_val), "r"); + if (ff) { + cfgReadConfig(ff, cfg); + fclose(ff); + } else + EDEBUG(ELWIX_DEBUG_LOG, "Error:: Can't open %s file", + AIT_GET_STR(&av->cfg_val)); + } + } + + return 0; } -// cfgWrite() Write to file from config list -static inline int cfgWrite(FILE *f, sl_config * __restrict cfg, int whitespace) +/* + * cfgWriteConfig() - Write config from memory + * + * @f = File handle + * @cfg = Config root + * @whitespace = Additional whitespace characters to file + * return: -1 error or 0 ok + */ +int +cfgWriteConfig(FILE *f, cfg_root_t * __restrict cfg, int whitespace) { - struct tagPair *av; - time_t tim; - char szTime[MAX_STR + 1]; - u_char szSection[MAX_STR + 1]; + struct tagCfg *av; + char line[BUFSIZ] = { 0 }, szSection[STRSIZ] = { [0 ... STRSIZ - 1] = 0 }; - bzero(szSection, MAX_STR + 1); - - bzero(szTime, MAX_STR + 1); - time(&tim); - strftime(szTime, MAX_STR, "(UTC) %Y-%m-%d %H:%M:%S", gmtime(&tim)); - if (!cfgDbg(f, "## Write Config :: %s\n#\n", szTime)) { - LOGERR; + if (!f || !cfg) { + cfg_SetErr(EINVAL, "Invalid parameter(s)"); return -1; } - InvertQueue(cfg); - for (av = cfg->slh_first; av; av = av->sle_next) { - if (av->psSection && strcmp((char*) av->psSection, (char*) szSection)) { - strlcpy((char*) szSection, (char*) av->psSection, MAX_STR + 1); - if (!cfgDbg(f, "\n[%s]\n", av->psSection)) { - LOGERR; - return -1; - } + CFG_RC_LOCK(cfg); + RB_FOREACH(av, tagRC, cfg) { + /* empty lines or comment */ + if (AIT_ISEMPTY(&av->cfg_attr)) { + if (AIT_ISEMPTY(&av->cfg_val)) + continue; + strlcpy(line, AIT_GET_STR(&av->cfg_val), sizeof line); + goto skip_sec; } - if (!av->psSection && *szSection) { - bzero(szSection, MAX_STR + 1); - if (!cfgDbg(f, "\n[]\n")) { - LOGERR; - return -1; - } - } - if (whitespace) { - if (!cfgDbg(f, "%s = %s\n", av->psAttribute, av->psValue)) { + /* section [] */ + if (!AIT_ISEMPTY(&av->cfg_sec) && AIT_ADDR(&av->cfg_sec) && + strcmp(AIT_GET_STRZ(&av->cfg_sec), szSection)) { + strlcpy(szSection, AIT_GET_STR(&av->cfg_sec), sizeof szSection); + if (!cfg_Write(f, "[%s]\n", AIT_GET_STR(&av->cfg_sec))) { LOGERR; + CFG_RC_UNLOCK(cfg); return -1; } - } else { - if (!cfgDbg(f, "%s=%s\n", av->psAttribute, av->psValue)) { + } else if (AIT_ISEMPTY(&av->cfg_sec) && *szSection) { + memset(szSection, 0, sizeof szSection); + if (!cfg_Write(f, "[]\n")) { LOGERR; + CFG_RC_UNLOCK(cfg); return -1; } } - } - InvertQueue(cfg); - bzero(szTime, MAX_STR + 1); - time(&tim); - strftime(szTime, MAX_STR, "(UTC) %Y-%m-%d %H:%M:%S", gmtime(&tim)); - if (!cfgDbg(f, "\n#\n## Done. :: %s\n", szTime)) { - LOGERR; - return -1; + /* build line */ + memset(line, 0, sizeof line); + if (!AIT_ISEMPTY(&av->cfg_attr) && AIT_TYPE(&av->cfg_attr) == string) { + strlcpy(line, AIT_GET_STRZ(&av->cfg_attr), sizeof line); + if (whitespace) + strlcat(line, " = ", sizeof line); + else + strlcat(line, "=", sizeof line); + } + if (!AIT_ISEMPTY(&av->cfg_val) && AIT_TYPE(&av->cfg_val) == string) { + if (av->cfg_quoted) + strlcat(line, "\"", sizeof line); + strlcat(line, AIT_GET_STRZ(&av->cfg_val), sizeof line); + if (av->cfg_quoted) + strlcat(line, "\"", sizeof line); + } +skip_sec: + /* write */ + if (!cfg_Write(f, "%s\n", line)) { + LOGERR; + CFG_RC_UNLOCK(cfg); + return -1; + } } + CFG_RC_UNLOCK(cfg); return 0; } -// --------------------------------------------------- - /* - * ReadConfig() Read from file and add new item to config list - * @f = file resource - * @cfg = Head list element - * return: 0 ok; -1 error:: can`t allocate memory -*/ -int ReadConfig(FILE *f, sl_config * __restrict cfg) + * cfgWriteConfigRaw() - Write config from memory by list + * + * @f = File handle + * @cfg = Config root + * @whitespace = Additional whitespace characters to file + * return: -1 error or 0 ok + */ +int +cfgWriteConfigRaw(FILE *f, cfg_root_t * __restrict cfg, int whitespace) { - u_char szLine[MAX_STR + 1]; - u_char szSection[MAX_STR + 1], *psAttr, *psVal; - int pos; - struct tagPair *av; + struct tagCfg *av, *nxt; + char line[BUFSIZ] = { 0 }, szSection[STRSIZ] = { [0 ... STRSIZ - 1] = 0 }; - memset(szSection, 0, MAX_STR + 1); - while (!feof(f)) { - memset(szLine, 0, MAX_STR + 1); - fgets((char*) szLine, MAX_STR, f); - trim(szLine); -#ifdef __DEBUG - cfgDbg(stdout, "DEBUG:: RAW |%s|\n", szLine); -#endif + if (!f || !cfg) { + cfg_SetErr(EINVAL, "Invalid parameter(s)"); + return -1; + } - // End of config - if (*szLine == '.') - break; - // Comment - if (*szLine == '#' || *szLine == ';' || !*szLine) - continue; - -#ifdef __DEBUG - cfgDbg(stdout, "DEBUG:: Clean |%s|\n", szLine); -#endif - - // Section - if (*szLine == '[') { - pos = strlen((char*) szLine) - 1; - if (szLine[pos] != ']') { -#ifdef __DEBUG - cfgDbg(stdout, "WARNING:: Ignore section %s ... not closed breket\n", szLine); -#endif - } else { - szLine[pos] = 0; - strncpy((char*) szSection, (char*) szLine + 1, MAX_STR); -#ifdef __DEBUG - cfgDbg(stdout, "DEBUG:: Section %s\n", szSection); -#endif - } - continue; + CFG_RC_LOCK(cfg); + TAILQ_FOREACH_SAFE(av, cfg, cfg_next, nxt) { + /* empty lines or comment */ + if (AIT_ISEMPTY(&av->cfg_attr)) { + if (AIT_ISEMPTY(&av->cfg_val)) + continue; + strlcpy(line, AIT_GET_STR(&av->cfg_val), sizeof line); + goto skip_sec; } - // Devide pairs - pos = strchr((char*) szLine, '=') ? strchr((char*) szLine, '=') - (char*) szLine : 0; - if (!pos) { -#ifdef __DEBUG - cfgDbg(stdout, "WARNING:: Ignore a/v %s ... format error!\n", szLine); -#endif - continue; - } else { - av = malloc(sizeof(struct tagPair)); - if (!av) { + /* section [] */ + if (!AIT_ISEMPTY(&av->cfg_sec) && AIT_ADDR(&av->cfg_sec) && + strcmp(AIT_GET_STRZ(&av->cfg_sec), szSection)) { + strlcpy(szSection, AIT_GET_STR(&av->cfg_sec), sizeof szSection); + if (!cfg_Write(f, "[%s]\n", AIT_GET_STR(&av->cfg_sec))) { LOGERR; + CFG_RC_UNLOCK(cfg); return -1; - } else { - memset(av, 0, sizeof(struct tagPair)); - // added new element - av->sle_next = cfg->slh_first; - cfg->slh_first = av; } - // added section name to element - if (*szSection) { - av->psSection = malloc(strlen((char*) szSection) + 1); - if (!av->psSection) { - LOGERR; - free(av); - return -1; - } else - strlcpy((char*) av->psSection, (char*) szSection, strlen((char*) szSection) + 1); - } else - av->psSection = NULL; - - psAttr = szLine; - psVal = (szLine + pos + 1); - szLine[pos] = 0; - rtrim(psAttr); - ltrim(psVal); - unquot(psVal); -#ifdef __DEBUG - cfgDbg(stdout, "DEBUG:: Attr(%p) ->%s size=%d Value(%p) ->%s size=%d\n", - psAttr, psAttr, strlen((char*) psAttr), psVal, psVal, strlen((char*) psVal)); -#endif - // added attribute to element - av->psAttribute = malloc(strlen((char*) psAttr) + 1); - if (!av->psAttribute) { + } else if (AIT_ISEMPTY(&av->cfg_sec) && *szSection) { + memset(szSection, 0, sizeof szSection); + if (!cfg_Write(f, "[]\n")) { LOGERR; - free(av->psSection); - free(av); + CFG_RC_UNLOCK(cfg); return -1; - } else - strlcpy((char*) av->psAttribute, (char*) psAttr, strlen((char*) psAttr) + 1); - // added value to element - av->psValue = malloc(strlen((char*) psVal) + 1); - if (!av->psValue) { - LOGERR; - free(av->psAttribute); - free(av->psSection); - free(av); - return -1; - } else - strlcpy((char*) av->psValue, (char*) psVal, strlen((char*) psVal) + 1); + } } + + /* build line */ + memset(line, 0, sizeof line); + if (!AIT_ISEMPTY(&av->cfg_attr) && AIT_TYPE(&av->cfg_attr) == string) { + strlcpy(line, AIT_GET_STRZ(&av->cfg_attr), sizeof line); + if (whitespace) + strlcat(line, " = ", sizeof line); + else + strlcat(line, "=", sizeof line); + } + if (!AIT_ISEMPTY(&av->cfg_val) && AIT_TYPE(&av->cfg_val) == string) { + if (av->cfg_quoted) + strlcat(line, "\"", sizeof line); + strlcat(line, AIT_GET_STRZ(&av->cfg_val), sizeof line); + if (av->cfg_quoted) + strlcat(line, "\"", sizeof line); + } +skip_sec: + /* write */ + if (!cfg_Write(f, "%s\n", line)) { + LOGERR; + CFG_RC_UNLOCK(cfg); + return -1; + } } + CFG_RC_UNLOCK(cfg); return 0; } - /* - * WriteConfig() Write to file from items in config list - * @f = file resource - * @cfg = Head list element - * return: 0 ok; -1 error:: can`t write to file -*/ -int WriteConfig(FILE *f, sl_config * __restrict cfg) + * cfgConcatConfig() - Concat two configs into one + * + * @cfg = Config root + * @add_cfg = Concated config will be destroy after merge + * return: -1 error or 0 ok + */ +int +cfgConcatConfig(cfg_root_t * __restrict cfg, cfg_root_t * __restrict add_cfg) { - return cfgWrite(f, cfg, 1); -} + struct tagCfg *item; -/* - * cfg_WriteConfig() Write to file from items in config list without whitespaces! - * @f = file resource - * @cfg = Head list element - * return: 0 ok; -1 error:: can`t write to file -*/ -int cfg_WriteConfig(FILE *f, sl_config * __restrict cfg) -{ - return cfgWrite(f, cfg, 0); -} - -/* - * ConcatConfig() Concat two list in one - * @cfg = Head list element of main list - * @add_cfg = Head list element of added list - * return: 0 ok; -1 error:: can`t concat lists -*/ -int ConcatConfig(sl_config * __restrict cfg, sl_config * __restrict add_cfg) -{ - struct tagPair *item; - int ret = 0; - if (!cfg || !add_cfg) return -1; - for (item = cfg->slh_first; item->sle_next; item = item->sle_next); - item->sle_next = add_cfg->slh_first; + CFG_RC_LOCK(add_cfg); + CFG_RC_LOCK(cfg); - add_cfg->slh_first = NULL; + /* concat lists & red-black trees */ + TAILQ_FOREACH(item, add_cfg, cfg_next) { + TAILQ_INSERT_TAIL(cfg, item, cfg_next); + RB_INSERT(tagRC, cfg, item); + } - return ret; + CFG_RC_UNLOCK(cfg); + + TAILQ_INIT(add_cfg); + RB_INIT(add_cfg); + CFG_RC_UNLOCK(add_cfg); + pthread_mutex_destroy(&add_cfg->rc_mtx); + return 0; } /* - * MergeConfig() Marge two list in one cfg and destroy add_cfg - * @cfg = Head list element of main list - * @add_cfg = Head list element of merged list (destroy after all!) - * return: 0 ok; -1 error:: can`t merge lists -*/ -int MergeConfig(sl_config * __restrict cfg, sl_config * __restrict add_cfg) + * cfgMergeConfig() - Marge two list in one cfg and destroy add_cfg + * + * @cfg = Config root of main list + * @add_cfg = Merged config will be destroy after merge + * return: -1 error or 0 ok + */ +int +cfgMergeConfig(cfg_root_t * __restrict cfg, cfg_root_t * __restrict add_cfg) { - struct tagPair *item, *merge, *add_next, *next = NULL; + struct tagCfg *item, *merge, *add_next, *next; int flg; if (!cfg || !add_cfg) return -1; - item = add_cfg->slh_first; - while (item) { - add_next = item->sle_next; + CFG_RC_LOCK(add_cfg); + CFG_RC_LOCK(cfg); - for (flg = 0, merge = cfg->slh_first, next = merge->sle_next; next; - merge = merge->sle_next, next = merge->sle_next) { - if (!merge->psSection && !item->psSection) { + /* merge lists */ + TAILQ_FOREACH_SAFE(item, add_cfg, cfg_next, add_next) { + flg = 0; + TAILQ_FOREACH_SAFE(merge, cfg, cfg_next, next) { + if (AIT_ISEMPTY(&merge->cfg_sec) && AIT_ISEMPTY(&item->cfg_sec)) { flg = 1; - merge->sle_next = item; - item->sle_next = next; break; } - if (merge->psSection && item->psSection && - !strcmp((char*) merge->psSection, (char*) item->psSection)) { - flg = 1; - merge->sle_next = item; - item->sle_next = next; + if (!AIT_ISEMPTY(&merge->cfg_sec) && !AIT_ISEMPTY(&item->cfg_sec) && + AIT_ADDR(&merge->cfg_sec) && AIT_ADDR(&item->cfg_sec) && + !strcmp(AIT_GET_STR(&merge->cfg_sec), AIT_GET_STR(&item->cfg_sec))) { + flg = -1; break; } } - if (!flg) { - if (!merge->sle_next) { - merge->sle_next = item; - item->sle_next = NULL; - } else - return -1; + switch (flg) { + case -1: + continue; /* skip duplicated element */ + case 1: + TAILQ_INSERT_AFTER(cfg, merge, item, cfg_next); + break; + case 0: + TAILQ_INSERT_TAIL(cfg, item, cfg_next); + break; } - - item = add_next; + RB_INSERT(tagRC, cfg, item); } - add_cfg->slh_first = NULL; + CFG_RC_UNLOCK(cfg); + TAILQ_INIT(add_cfg); + RB_INIT(add_cfg); + CFG_RC_UNLOCK(add_cfg); + pthread_mutex_destroy(&add_cfg->rc_mtx); return 0; +} + +/* + * cfgReadLines() - Read custom lines and add new item at config root + * + * @f = File resource + * @delim = Custom delimiter, if =NULL default is '=' + * @end = Custom user end of file, if =NULL default is EOF + * @cfg = Config root + * return: -1 error or 0 ok + */ +int +cfgReadLines(FILE *f, const char *delim, const char *end, cfg_root_t * __restrict cfg) +{ + char line[BUFSIZ]; + struct tagCfg *d, *av = NULL; + char *p, *psSec, *psAttr, *psVal; + + if (!cfg) + return -1; + if (!delim) + delim = ATR_LINES_DELIM; + + while (!feof(f)) { + psSec = psAttr = psVal = NULL; + memset(line, 0, sizeof line); + if (!fgets(line, sizeof(line) - 1, f)) + break; + /* check for user end-of-file */ + if (strspn(line, end)) + break; + + if (!(psAttr = strpbrk(line, "\r\n"))) { + /* skip line, too long */ + continue; + } else { + *psAttr = 0; + str_Trim(line); + if (!*line) + continue; + } + + if (!av_MakeExt(line, delim, &p, &psVal)) + continue; + else { + str_RTrim(p); + str_LTrim(psVal); + } + if (!av_MakeExt(p, SEC_LINES_DELIM, &psSec, &psAttr)) + psAttr = p; + + /* check for duplicated element */ + if (psAttr && cfg_findAttribute(cfg, psSec, psAttr)) + cfg_unsetAttribute(cfg, psSec, psAttr); + + /* *NEW PAIR* alloc new pair element */ + av = e_malloc(sizeof(struct tagCfg)); + if (!av) { + LOGERR; + return -1; + } else + memset(av, 0, sizeof(struct tagCfg)); + + if (psSec) { + AIT_SET_STR(&av->cfg_sec, psSec); + AIT_KEY(&av->cfg_sec) = crcFletcher16(AIT_GET_LIKE(&av->cfg_sec, u_short*), + E_ALIGN(AIT_LEN(&av->cfg_sec) - 1, 2) / 2); + } + if (psVal) { + av->cfg_quoted = str_Unquot(psVal); + AIT_SET_STR(&av->cfg_val, psVal); + } + AIT_SET_STR(&av->cfg_attr, psAttr); + AIT_KEY(&av->cfg_attr) = crcFletcher16(AIT_GET_LIKE(&av->cfg_attr, u_short*), + E_ALIGN(AIT_LEN(&av->cfg_attr) - 1, 2) / 2); + + CFG_RC_LOCK(cfg); + /* find & delete duplicates */ + if ((d = RB_FIND(tagRC, cfg, av))) { + RB_REMOVE(tagRC, cfg, d); + TAILQ_REMOVE(cfg, d, cfg_next); + + AIT_FREE_VAL(&d->cfg_val); + AIT_FREE_VAL(&d->cfg_attr); + AIT_FREE_VAL(&d->cfg_sec); + e_free(d); + } + + TAILQ_INSERT_TAIL(cfg, av, cfg_next); + RB_INSERT(tagRC, cfg, av); + CFG_RC_UNLOCK(cfg); + } + + return 0; +} + +/* + * cfgWriteLines() - Write custom lines and export data to variable + * + * @f = File resource + * @delim = Custom delimiter, if =NULL default is '=' + * @eol = End of line string, if =NULL default is "\n" + * @section = Export only section, if =NULL default is all + * @cfg = Config root + * return: =NULL error or !=NULL exported data, must be free after use with ait_freeVar() + */ +ait_val_t * +cfgWriteLines(FILE *f, const char *delim, const char *eol, const char *section, cfg_root_t * __restrict cfg) +{ + ait_val_t *v = NULL; + struct tagCfg *av; + + if (!cfg) + return NULL; + if (!delim) + delim = ATR_LINES_DELIM; + if (!eol) + eol = EOL_LINES_DELIM; + if (!(v = ait_allocVar())) { + cfg_SetErr(elwix_GetErrno(), "%s", elwix_GetError()); + return NULL; + } else + AIT_INIT_VAL2(v, string); + + TAILQ_FOREACH(av, cfg, cfg_next) { + if (section) { + if (!AIT_ISEMPTY(&av->cfg_sec) && *section) + continue; + if (strcmp(section, AIT_GET_STRZ(&av->cfg_sec))) + continue; + } + + if (!AIT_ISEMPTY(&av->cfg_sec)) { + AIT_SET_STRCAT(v, AIT_GET_STR(&av->cfg_sec)); + AIT_SET_STRCAT(v, SEC_LINES_DELIM); + } + if (!AIT_ISEMPTY(&av->cfg_attr)) { + AIT_SET_STRCAT(v, AIT_GET_STR(&av->cfg_attr)); + AIT_SET_STRCAT(v, delim); + } + if (!AIT_ISEMPTY(&av->cfg_val)) { + if (av->cfg_quoted) + AIT_SET_STRCAT(v, "\""); + AIT_SET_STRCAT(v, AIT_GET_STR(&av->cfg_val)); + if (av->cfg_quoted) + AIT_SET_STRCAT(v, "\""); + } + AIT_SET_STRCAT(v, eol); + } + + if (f) + fputs(AIT_GET_STR(v), f); + return v; }