version 1.4, 2010/03/22 14:53:49
|
version 1.21, 2023/01/23 23:27:26
|
Line 5
|
Line 5
|
* $Author$ |
* $Author$ |
* $Id$ |
* $Id$ |
* |
* |
*************************************************************************/ | ************************************************************************** |
#include "global.h" | The ELWIX and AITNET software is distributed under the following |
#include "aitcfg.h" | terms: |
#include "tools.h" | |
|
|
|
All of the documentation and software included in the ELWIX and AITNET |
|
Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org> |
|
|
// cfgDbg() Debug/Log operation | Copyright 2004 - 2023 |
static inline int cfgDbg(FILE *f, char *fmt, ...) | by Michael Pounov <misho@elwix.org>. All rights reserved. |
{ | |
int ret = 0; | |
va_list lst; | |
|
|
va_start(lst, fmt); | Redistribution and use in source and binary forms, with or without |
ret = vfprintf(f, fmt, lst); | modification, are permitted provided that the following conditions |
va_end(lst); | 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 <misho@elwix.org> |
| 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 | * cfgReadConfig() - Read file and add new item at config root |
* @cfg = Head list element for revert | * |
*/ | * @f = File resource |
static inline void InvertQueue(sl_config * __restrict cfg) | * @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) { | if (!f || !cfg) { |
next = item->sle_next; | cfg_SetErr(EINVAL, "Invalid parameter(s)"); |
item->sle_next = prev; | return -1; |
prev = item; | |
} |
} |
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; | struct tagCfg *av; |
time_t tim; | char line[BUFSIZ] = { 0 }, szSection[STRSIZ] = { [0 ... STRSIZ - 1] = 0 }; |
char szTime[MAX_STR + 1]; | |
u_char szSection[MAX_STR + 1]; | |
|
|
bzero(szSection, MAX_STR + 1); | if (!f || !cfg) { |
| cfg_SetErr(EINVAL, "Invalid parameter(s)"); |
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; | |
return -1; |
return -1; |
} |
} |
|
|
InvertQueue(cfg); | CFG_RC_LOCK(cfg); |
for (av = cfg->slh_first; av; av = av->sle_next) { | RB_FOREACH(av, tagRC, cfg) { |
if (av->psSection && strcmp((char*) av->psSection, (char*) szSection)) { | /* empty lines or comment */ |
strlcpy((char*) szSection, (char*) av->psSection, MAX_STR + 1); | if (AIT_ISEMPTY(&av->cfg_attr)) { |
if (!cfgDbg(f, "\n[%s]\n", av->psSection)) { | if (AIT_ISEMPTY(&av->cfg_val)) |
LOGERR; | continue; |
return -1; | 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) { | /* section [] */ |
if (!cfgDbg(f, "%s = %s\n", av->psAttribute, av->psValue)) { | 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; |
LOGERR; |
|
CFG_RC_UNLOCK(cfg); |
return -1; |
return -1; |
} |
} |
} else { | } else if (AIT_ISEMPTY(&av->cfg_sec) && *szSection) { |
if (!cfgDbg(f, "%s=%s\n", av->psAttribute, av->psValue)) { | memset(szSection, 0, sizeof szSection); |
| if (!cfg_Write(f, "[]\n")) { |
LOGERR; |
LOGERR; |
|
CFG_RC_UNLOCK(cfg); |
return -1; |
return -1; |
} |
} |
} |
} |
} |
|
InvertQueue(cfg); |
|
|
|
bzero(szTime, MAX_STR + 1); | /* build line */ |
time(&tim); | memset(line, 0, sizeof line); |
strftime(szTime, MAX_STR, "(UTC) %Y-%m-%d %H:%M:%S", gmtime(&tim)); | if (!AIT_ISEMPTY(&av->cfg_attr) && AIT_TYPE(&av->cfg_attr) == string) { |
if (!cfgDbg(f, "\n#\n## Done. :: %s\n", szTime)) { | strlcpy(line, AIT_GET_STRZ(&av->cfg_attr), sizeof line); |
LOGERR; | if (whitespace) |
return -1; | 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; |
return 0; |
} |
} |
|
|
// --------------------------------------------------- |
|
|
|
/* |
/* |
* ReadConfig() Read from file and add new item to config list | * cfgWriteConfigRaw() - Write config from memory by list |
* @f = file resource | * |
* @cfg = Head list element | * @f = File handle |
* return: 0 ok; -1 error:: can`t allocate memory | * @cfg = Config root |
*/ | * @whitespace = Additional whitespace characters to file |
int ReadConfig(FILE *f, sl_config * __restrict cfg) | * return: -1 error or 0 ok |
| */ |
| int |
| cfgWriteConfigRaw(FILE *f, cfg_root_t * __restrict cfg, int whitespace) |
{ |
{ |
u_char szLine[MAX_STR + 1]; | struct tagCfg *av, *nxt; |
u_char szSection[MAX_STR + 1], *psAttr, *psVal; | char line[BUFSIZ] = { 0 }, szSection[STRSIZ] = { [0 ... STRSIZ - 1] = 0 }; |
int pos; | |
struct tagPair *av; | |
|
|
memset(szSection, 0, MAX_STR + 1); | if (!f || !cfg) { |
while (!feof(f)) { | cfg_SetErr(EINVAL, "Invalid parameter(s)"); |
memset(szLine, 0, MAX_STR + 1); | return -1; |
fgets((char*) szLine, MAX_STR, f); | } |
trim(szLine); | |
#ifdef __DEBUG | |
cfgDbg(stdout, "DEBUG:: RAW |%s|\n", szLine); | |
#endif | |
|
|
// End of config | CFG_RC_LOCK(cfg); |
if (*szLine == '.') | TAILQ_FOREACH_SAFE(av, cfg, cfg_next, nxt) { |
break; | /* empty lines or comment */ |
// Comment | if (AIT_ISEMPTY(&av->cfg_attr)) { |
if (*szLine == '#' || *szLine == ';' || !*szLine) | if (AIT_ISEMPTY(&av->cfg_val)) |
continue; | continue; |
| strlcpy(line, AIT_GET_STR(&av->cfg_val), sizeof line); |
#ifdef __DEBUG | goto skip_sec; |
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; | |
} |
} |
|
|
// Devide pairs | /* section [] */ |
pos = strchr((char*) szLine, '=') ? strchr((char*) szLine, '=') - (char*) szLine : 0; | if (!AIT_ISEMPTY(&av->cfg_sec) && AIT_ADDR(&av->cfg_sec) && |
if (!pos) { | strcmp(AIT_GET_STRZ(&av->cfg_sec), szSection)) { |
#ifdef __DEBUG | strlcpy(szSection, AIT_GET_STR(&av->cfg_sec), sizeof szSection); |
cfgDbg(stdout, "WARNING:: Ignore a/v %s ... format error!\n", szLine); | if (!cfg_Write(f, "[%s]\n", AIT_GET_STR(&av->cfg_sec))) { |
#endif | |
continue; | |
} else { | |
av = malloc(sizeof(struct tagPair)); | |
if (!av) { | |
LOGERR; |
LOGERR; |
|
CFG_RC_UNLOCK(cfg); |
return -1; |
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 | } else if (AIT_ISEMPTY(&av->cfg_sec) && *szSection) { |
if (*szSection) { | memset(szSection, 0, sizeof szSection); |
av->psSection = malloc(strlen((char*) szSection) + 1); | if (!cfg_Write(f, "[]\n")) { |
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) { | |
LOGERR; |
LOGERR; |
free(av->psSection); | CFG_RC_UNLOCK(cfg); |
free(av); | |
return -1; |
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; |
return 0; |
} |
} |
|
|
/* |
/* |
* WriteConfig() Write to file from items in config list | * cfgConcatConfig() - Concat two configs into one |
* @f = file resource | * |
* @cfg = Head list element | * @cfg = Config root |
* return: 0 ok; -1 error:: can`t write to file | * @add_cfg = Concated config will be destroy after merge |
*/ | * return: -1 error or 0 ok |
int WriteConfig(FILE *f, sl_config * __restrict cfg) | */ |
| 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) |
if (!cfg || !add_cfg) |
return -1; |
return -1; |
|
|
for (item = cfg->slh_first; item->sle_next; item = item->sle_next); | CFG_RC_LOCK(add_cfg); |
item->sle_next = add_cfg->slh_first; | 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 | * cfgMergeConfig() - 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!) | * @cfg = Config root of main list |
* return: 0 ok; -1 error:: can`t merge lists | * @add_cfg = Merged config will be destroy after merge |
*/ | * return: -1 error or 0 ok |
int MergeConfig(sl_config * __restrict cfg, sl_config * __restrict add_cfg) | */ |
| 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; |
int flg; |
|
|
if (!cfg || !add_cfg) |
if (!cfg || !add_cfg) |
return -1; |
return -1; |
|
|
item = add_cfg->slh_first; | CFG_RC_LOCK(add_cfg); |
while (item) { | CFG_RC_LOCK(cfg); |
add_next = item->sle_next; | |
|
|
for (flg = 0, merge = cfg->slh_first, next = merge->sle_next; next; | /* merge lists */ |
merge = merge->sle_next, next = merge->sle_next) { | TAILQ_FOREACH_SAFE(item, add_cfg, cfg_next, add_next) { |
if (!merge->psSection && !item->psSection) { | flg = 0; |
| TAILQ_FOREACH_SAFE(merge, cfg, cfg_next, next) { |
| if (AIT_ISEMPTY(&merge->cfg_sec) && AIT_ISEMPTY(&item->cfg_sec)) { |
flg = 1; |
flg = 1; |
merge->sle_next = item; |
|
item->sle_next = next; |
|
break; |
break; |
} |
} |
if (merge->psSection && item->psSection && | if (!AIT_ISEMPTY(&merge->cfg_sec) && !AIT_ISEMPTY(&item->cfg_sec) && |
!strcmp((char*) merge->psSection, (char*) item->psSection)) { | AIT_ADDR(&merge->cfg_sec) && AIT_ADDR(&item->cfg_sec) && |
flg = 1; | !strcmp(AIT_GET_STR(&merge->cfg_sec), AIT_GET_STR(&item->cfg_sec))) { |
merge->sle_next = item; | flg = -1; |
item->sle_next = next; | |
break; |
break; |
} |
} |
} |
} |
|
|
if (!flg) { | switch (flg) { |
if (!merge->sle_next) { | case -1: |
merge->sle_next = item; | continue; /* skip duplicated element */ |
item->sle_next = NULL; | case 1: |
} else | TAILQ_INSERT_AFTER(cfg, merge, item, cfg_next); |
return -1; | break; |
| case 0: |
| TAILQ_INSERT_TAIL(cfg, item, cfg_next); |
| break; |
} |
} |
| RB_INSERT(tagRC, cfg, item); |
item = add_next; | |
} |
} |
|
|
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; |
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; |
} |
} |