--- libaitcfg/src/aitcfg.c 2009/09/09 09:07:31 1.2 +++ libaitcfg/src/aitcfg.c 2014/01/30 08:30:47 1.11 @@ -3,99 +3,221 @@ * by Michael Pounov * * $Author: misho $ -* $Id: aitcfg.c,v 1.2 2009/09/09 09:07:31 misho Exp $ +* $Id: aitcfg.c,v 1.11 2014/01/30 08:30:47 misho Exp $ * -*************************************************************************/ +************************************************************************** +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 + +Copyright 2004 - 2014 + by Michael Pounov . All rights reserved. + +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. + +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" -#include "aitcfg.h" #pragma GCC visibility push(hidden) -int cfgErrno; -char cfgError[MAX_STR + 1]; +int cfg_Errno; +char cfg_Error[STRSIZ]; +int +cfg_Write(FILE *f, char *fmt, ...) +{ + int ret = 0; + va_list lst; + + va_start(lst, fmt); + ret = vfprintf(f, fmt, lst); + va_end(lst); + + return ret; +} + +int +cfg_tree_cmp(struct tagCfg *a, struct tagCfg *b) +{ + int ret; + + assert(a && b); + + ret = ((AIT_KEY(&a->cfg_sec) << 16) | AIT_KEY(&a->cfg_attr)) - + ((AIT_KEY(&b->cfg_sec) << 16) | AIT_KEY(&b->cfg_attr)); + + if (ret < 0) + return -1; + else if (ret > 0) + return 1; + + return ret; +} + +RB_GENERATE(tagRC, tagCfg, cfg_node, cfg_tree_cmp); + #pragma GCC visibility pop +// cfg_GetErrno() Get error code of last operation +int +cfg_GetErrno() +{ + return cfg_Errno; +} + +// cfg_GetError() Get error text of last operation +const char * +cfg_GetError() +{ + return cfg_Error; +} + +// cfg_SetErr() Set error to variables for internal use!!! +void +cfg_SetErr(int eno, char *estr, ...) +{ + va_list lst; + + cfg_Errno = eno; + memset(cfg_Error, 0, sizeof cfg_Error); + va_start(lst, estr); + vsnprintf(cfg_Error, sizeof cfg_Error, estr, lst); + va_end(lst); +} + + /* - * InitConfig() Head initializing function for config - * @cfg = New head element for init - * return: 0 ok; -1 error:: new head element is null -*/ -inline int InitConfig(sl_config * __restrict cfg) + * cfgInitConfig() - Init config root + * + * @cfg = Config root + * return: -1 error or 0 ok + */ +int +cfgInitConfig(cfg_root_t * __restrict cfg) { if (!cfg) return -1; - cfg->slh_first = NULL; + pthread_mutex_init(&cfg->rc_mtx, NULL); + + TAILQ_INIT(cfg); + RB_INIT(cfg); return 0; } /* - * LoadConfig() Load config from file - * @csConfigName = Filename of config - * @cfg = Head list element - * return: 0 ok; -1 error:: can`t load config -*/ -int LoadConfig(const char *csConfigName, sl_config * __restrict cfg) + * cfgLoadConfig() - Load config from file + * + * @cfgName = Config filename + * @cfg = Config root + * return: -1 error or 0 ok + */ +int +cfgLoadConfig(const char *cfgName, cfg_root_t * __restrict cfg) { FILE *f; int ret; - if (!csConfigName || !cfg) + if (!cfgName || !cfg) { + cfg_SetErr(EINVAL, "Invalid parameter(s)"); return -1; + } else + cfgInitConfig(cfg); - InitConfig(cfg); - if (access(csConfigName, R_OK)) { - LOGERR; - return -1; - } - - f = fopen(csConfigName, "rt"); + f = fopen(cfgName, "r"); if (!f) { LOGERR; return -1; } - - ret ^= ret; - ret = ReadConfig(f, cfg); + ret = cfgReadConfig(f, cfg); + fclose(f); return ret; } /* - * UnloadConfig() Unload config from memory and free resources - * @cfg = Head list element -*/ -void UnloadConfig(sl_config * __restrict cfg) + * cfgClearConfig() - Clear config and free resources + * + * @cfg = Config root + * return: none + */ +void +cfgClearConfig(cfg_root_t * __restrict cfg) { - struct tagPair *av; + struct tagCfg *av; - if (!cfg->slh_first) + if (!cfg) return; - while ((av = cfg->slh_first)) { - cfg->slh_first = cfg->slh_first->sle_next; + CFG_RC_LOCK(cfg); + while ((av = TAILQ_FIRST(cfg))) { + TAILQ_REMOVE(cfg, av, cfg_next); - if (av->psValue) - free(av->psValue); - if (av->psAttribute) - free(av->psAttribute); - if (av->psSection) - free(av->psSection); - free(av); + AIT_FREE_VAL(&av->cfg_val); + AIT_FREE_VAL(&av->cfg_attr); + AIT_FREE_VAL(&av->cfg_sec); + e_free(av); } + cfg->rbh_root = NULL; + CFG_RC_UNLOCK(cfg); } /* - * CreateConfig() Create config file from memory + * cfgUnloadConfig() - Unload config from memory and destroy resources + * + * @cfg = Config root + * return: none + */ +void +cfgUnloadConfig(cfg_root_t * __restrict cfg) +{ + if (!cfg) + return; + + cfgClearConfig(cfg); + pthread_mutex_destroy(&cfg->rc_mtx); +} + +/* + * cfgCreateConfig() - Create config file from memory + * * @csConfigName = New config filename - * @cfg = Head list element - * return: 0 ok; -1 error:: can`t save new config -*/ -int CreateConfig(const char *csConfigName, sl_config * __restrict cfg) + * @cfg = Config root + * @whitespace = Additional whitespace characters to file + * return: -1 error or 0 ok + */ +int +cfgCreateConfig(const char *csConfigName, cfg_root_t * __restrict cfg, int whitespace) { FILE *f; int ret; @@ -103,33 +225,142 @@ int CreateConfig(const char *csConfigName, sl_config * if (!csConfigName || !cfg) return -1; - f = fopen(csConfigName, "wt"); + f = fopen(csConfigName, "w"); if (!f) { LOGERR; return -1; } - ret ^= ret; - ret = WriteConfig(f, cfg); + ret = cfgWriteConfig(f, cfg, whitespace); fclose(f); return ret; } -// ----------------------------------------------------------- +/* + * cfgInitPasswd() - Init password root + * + * @pwd = Password root + * return: -1 error or 0 ok + */ +int +cfgInitPasswd(pwd_root_t * __restrict pwd) +{ + if (!pwd) + return -1; -// -// Error maintenance functions ... -// + pthread_mutex_init(&pwd->pwd_mtx, NULL); -// cfg_GetErrno() Get error code of last operation -inline int cfg_GetErrno() + SLIST_INIT(pwd); + RB_INIT(pwd); + return 0; +} + +/* + * cfgLoadPasswd() - Load passwords from file + * + * @pwdName = Passwords filename + * @pwd = Password root + * return: -1 error or 0 ok + */ +int +cfgLoadPasswd(const char *pwdName, pwd_root_t * __restrict pwd) { - return cfgErrno; + FILE *f; + int ret; + + if (!pwdName || !pwd) { + cfg_SetErr(EINVAL, "Invalid parameter(s)"); + return -1; + } else + cfgInitPasswd(pwd); + + f = fopen(pwdName, "r"); + if (!f) { + LOGERR; + return -1; + } + + ret = cfgReadPasswd(f, pwd); + + fclose(f); + return ret; } -// cfg_GetError() Get error text of last operation -inline const char *cfg_GetError() +/* + * cfgClearPasswd() - Clear passwords and free resources + * + * @cfg = Password root + * return: none + */ +void +cfgClearPasswd(pwd_root_t * __restrict pwd) { - return cfgError; + struct tagUser *p; + + if (!pwd) + return; + + PWD_LOCK(pwd); + while ((p = SLIST_FIRST(pwd))) { + SLIST_REMOVE_HEAD(pwd, usr_next); + + AIT_FREE_VAL(&p->usr_name); + AIT_FREE_VAL(&p->usr_pass); + AIT_FREE_VAL(&p->usr_uid); + AIT_FREE_VAL(&p->usr_gid); + AIT_FREE_VAL(&p->usr_class); + AIT_FREE_VAL(&p->usr_change); + AIT_FREE_VAL(&p->usr_expire); + AIT_FREE_VAL(&p->usr_realm); + AIT_FREE_VAL(&p->usr_home); + AIT_FREE_VAL(&p->usr_shell); + e_free(p); + } + pwd->rbh_root = NULL; + PWD_UNLOCK(pwd); +} + +/* + * cfgUnloadPasswd() - Unload passwords from memory and destroy resources + * + * @pwd = Password root + * return: none + */ +void +cfgUnloadPasswd(pwd_root_t * __restrict pwd) +{ + if (!pwd) + return; + + cfgClearPasswd(pwd); + pthread_mutex_destroy(&pwd->pwd_mtx); +} + +/* + * cfgCreatePasswd() - Create password file from memory + * + * @pwdName = New password filename + * @pwd = Password root + * return: -1 error or 0 ok + */ +int +cfgCreatePasswd(const char *pwdName, pwd_root_t * __restrict pwd) +{ + FILE *f; + int ret; + + if (!pwdName || !pwd) + return -1; + + f = fopen(pwdName, "w"); + if (!f) { + LOGERR; + return -1; + } + + ret = cfgWritePasswd(f, pwd); + + fclose(f); + return ret; }