int config_get_host(config_t *config,char **host){
config_setting_t *cs_host=NULL;
if((cs_host=config_lookup(config,"host"))==NULL){
return 1;
}
if((*host=strdup(config_setting_get_string(cs_host)))==NULL){
free(*host);
*host=NULL;
return 1;
}
return 0;
}
int config_setting_lookup_string (const config_setting_t * setting, const char *name, const char **value)
{
config_setting_t *member = config_setting_get_member (setting, name);
if (!member)
return (CONFIG_FALSE);
if (config_setting_type (member) != CONFIG_TYPE_STRING)
return (CONFIG_FALSE);
*value = config_setting_get_string (member);
return (CONFIG_TRUE);
}
int qtbl32_set(config_setting_t *cfsp, struct qtbl_e *qep, struct qtbl_e ifsnmpoid) {
config_setting_t *tcfsp;
if((tcfsp = config_setting_get_member(cfsp, "static")) != NULL){
qep->data.val = config_setting_get_int(tcfsp);
qep->flag = QSTATIC;
return 1;
/* SNMP is default. if SNMP option is not found, to assume SNMP MIB */
}else if((tcfsp = config_setting_get_member(cfsp, "snmp")) == NULL){
tcfsp = cfsp;
}
if(ifsnmpoid.flag != QSNMPOID){
printf("Not defined SNMP data\n");
return 0;
}
if(strlen(config_setting_get_string(tcfsp)) == 0){
printf("wrong OID data\n");
return 0;
}
*qep = ifsnmpoid;
strncpy(qep->data.snmp.oid, config_setting_get_string(tcfsp), MAX_OID_LEN);
return 1;
}
/*******************************************************************************
函数名称 : webauth_rdx_get_str_setting
功能描述 : 从配置结构中读取字符串类型的属性
输入参数 : config_setting_t * setting 配置结构
char* attr 配置属性名
size_t buf_len 缓冲区长度
输出参数 : char *buf 缓冲区
返 回 值 :
--------------------------------------------------------------------------------
最近一次修改记录 :
修改作者 : 王群
修改目的 : 新添加函数
修改日期 : 2010-08-16
*******************************************************************************/
void webauth_rdx_get_str_setting (config_setting_t * setting, char *attr,
char *buf, size_t buf_len)
{
config_setting_t *s;
s = config_setting_get_member (setting, attr);
if (NULL != s)
{
strncpy (buf, config_setting_get_string (s), buf_len);
}
return;
}
int config_lookup_string (const config_t * config, const char *path, const char **value)
{
const config_setting_t *s = config_lookup (config, path);
if (!s)
return (CONFIG_FALSE);
if (config_setting_type (s) != CONFIG_TYPE_STRING)
return (CONFIG_FALSE);
*value = config_setting_get_string (s);
return (CONFIG_TRUE);
}
int get_server_config(s_config *c, char *config_path)
{
config_t cfg;
config_setting_t *modules_setting, *module_setting;
unsigned int count, i;
const char *module_name;
config_init(&cfg);
if (!config_read_file(&cfg, config_path)) {
config_destroy(&cfg);
return CONFIG_FILE_READ_ERROR;
}
if (config_lookup_int(&cfg, "port", &(c->port))
&& config_lookup_string(&cfg, "host", &(c->host))
&& config_lookup_string(&cfg, "web_root", &(c->web_root))
&& config_lookup_string(&cfg, "web_prefix", &(c->web_prefix))
&& config_lookup_string(&cfg, "api_prefix", &(c->api_prefix))
&& config_lookup_string(&cfg, "index_file", &(c->index_file))
&& config_lookup_string(&cfg, "api_modules_path", &(c->api_modules_path))
&& config_lookup_int(&cfg, "buffer_size", &(c->buffer_size))
&& config_lookup_int(&cfg, "api_modules_number", &(c->api_modules_number))
) {
c->buffer = (char*) calloc((size_t) c->buffer_size, sizeof(char));
/* Output a list of all movies in the inventory. */
modules_setting = config_lookup(&cfg, "api_modules");
if (modules_setting != NULL) {
count = (unsigned int) config_setting_length(modules_setting);
if (count != (unsigned int) c->api_modules_number)
return CONFIG_INCONSISTENT_DATA;
else if (count == 0)
return CONFIG_FILE_READ_OK;
c->api_modules_names = malloc(count * sizeof(char*));
for (i = 0; i < count; ++i) {
module_setting = config_setting_get_elem(modules_setting, i);
module_name = config_setting_get_string(module_setting);
c->api_modules_names[i] = module_name;
}
map_init(&c->api_modules, c->api_modules_number);
}
return CONFIG_FILE_READ_OK;
}
else
return CONFIG_MISSING_KEY;
}
int config_get_port(config_t *config,char **port){
config_setting_t *cs_port=NULL;
if((cs_port=config_lookup(config,"port"))==NULL){
return 1;
}
switch(config_setting_type(cs_port)){
case CONFIG_TYPE_INT:
*port=calloc(16,sizeof(*port));
sprintf(*port,"%lu",config_setting_get_int(cs_port));
return 0;
case CONFIG_TYPE_STRING:
*port=strdup(config_setting_get_string(cs_port));
return 0;
}
return 1;
}
static int checkValues(struct JsonNode *jvalues) {
double readonly = 0.0;
char *platform = GPIO_PLATFORM;
if(config_setting_get_string("gpio-platform", 0, &platform) != 0) {
logprintf(LOG_ERR, "no gpio-platform configured");
return -1;
}
if(strcmp(platform, "none") == 0) {
FREE(platform);
logprintf(LOG_ERR, "no gpio-platform configured");
return -1;
}
if(wiringXSetup(platform, logprintf1) < 0) {
FREE(platform);
return -1;
}
FREE(platform);
struct JsonNode *jid = NULL;
if((jid = json_find_member(jvalues, "id"))) {
struct JsonNode *jchild = NULL;
struct JsonNode *jchild1 = NULL;
jchild = json_first_child(jid);
while(jchild) {
jchild1 = json_first_child(jchild);
while(jchild1) {
if(strcmp(jchild1->key, "gpio") == 0) {
if(wiringXValidGPIO((int)round(jchild1->number_)) != 0) {
return -1;
}
}
jchild1 = jchild1->next;
}
jchild = jchild->next;
}
}
if(json_find_number(jvalues, "readonly", &readonly) == 0) {
if((int)readonly != 1) {
return -1;
}
}
return 0;
}
static int parse_rpms(struct config_t *config, struct manifest *manifest)
{
config_setting_t *rpms = config_lookup(config, "manifest");
config_setting_t *rpm_config;
/*__free_rpms*/ struct rpm *rpmp = NULL;
struct rpm *last = manifest->rpms;
int i = 0;
const char *name;
if (!rpms)
return 0;
//printf("*-* *-*\n");
/*
* Load up all the individual repository urls
*/
while ((rpm_config = config_setting_get_elem(rpms, i)) != NULL) {
name = config_setting_get_string(rpm_config);
if (!name)
return -EINVAL;
rpmp = calloc(1, sizeof(struct rpm));
if (!rpmp)
return -ENOMEM;
rpmp->name = strdup(name);
if (!rpmp->name)
return -ENOMEM;
//printf(" ** %s [%p %p %p]\n", rpmp->name, rpmp, last, rpmp->name);
rpmp->next = NULL;
if (last)
last->next = rpmp;
else
manifest->rpms = rpmp;
last = rpmp;
i++;
}
//printf("*=* *=*\n");
rpmp = NULL;
return 0;
}
void sub_shc_popexec(int value)
{
shc_node *item = shc_root;
config_setting_t *root = config_lookup(&CONFIG, "shortcuts");
char bname[1024];
int i = 0;
memset(bname, 0, sizeof(bname));
for (i = 0; item != NULL && i < shc_selection; item = item->next, i++);
if (!item || !root)
return;
switch (value)
{
case 0:
{
for (i = config_setting_length(root); i--;)
{
config_setting_t *elem = config_setting_get_elem(root, i);
config_setting_t *member =
config_setting_get_member(elem, "path");
if (member)
{
if (!strcmp(config_setting_get_string(member),item->path))
{
sub_game_remove_shortcut(root, i);
msgbox(SDL_GetVideoSurface(),NULL, "My Shortcuts",
"Shortcut has been deleted.", OK);
cfg_save();
msgbox_retval();
return;
}
}
}
msgbox(SDL_GetVideoSurface(),NULL,"System Error","Unable to delete Shortcut.",
OK);
msgbox_retval();
}
break;
default:
break;
}
}
void gpio_initpgm(PROGRAMMER *pgm)
{
#if defined(__arm__) || defined(__mips__)
strcpy(pgm->type, "GPIO");
char *platform = GPIO_PLATFORM;
if(config_setting_get_string("gpio-platform", 0, &platform) != 0) {
logprintf(LOG_ERR, "no gpio-platform configured");
exit(EXIT_FAILURE);
}
if(strcmp(platform, "none") == 0) {
FREE(platform);
logprintf(LOG_ERR, "no gpio-platform configured");
exit(EXIT_FAILURE);
}
if(wiringXSetup(platform, logprintf1) < 0) {
FREE(platform);
exit(EXIT_FAILURE);
}
FREE(platform);
pgm->rdy_led = bitbang_rdy_led;
pgm->err_led = bitbang_err_led;
pgm->pgm_led = bitbang_pgm_led;
pgm->vfy_led = bitbang_vfy_led;
pgm->initialize = bitbang_initialize;
pgm->display = gpio_display;
pgm->enable = gpio_enable;
pgm->disable = gpio_disable;
pgm->powerup = gpio_powerup;
pgm->powerdown = gpio_powerdown;
pgm->program_enable = bitbang_program_enable;
pgm->chip_erase = bitbang_chip_erase;
pgm->cmd = bitbang_cmd;
pgm->open = gpio_open;
pgm->close = gpio_close;
pgm->setpin = gpio_setpin;
pgm->getpin = gpio_getpin;
pgm->highpulsepin = gpio_highpulsepin;
pgm->read_byte = avr_read_byte_default;
pgm->write_byte = avr_write_byte_default;
#else
logprintf(LOG_WARNING, "gpio firmware flashing is not supported on this hardware");
exit(EXIT_FAILURE);
#endif
}
int jalu_config_lookup_string(const config_setting_t *setting,
const char *name, char **field, int required) {
if (!setting || !name || !field || *field) {
//library error, should never happen
fprintf(stderr, "Error: misuse of jalls_config_lookup_string\n");
goto err_out;
}
config_setting_t *member = config_setting_get_member(setting, name);
if (!member && required) {
fprintf(stderr, "Config Error: line %d: missing required field \"%s\"\n",
config_setting_source_line(setting), name);
goto err_out;
}
if (!member) {
goto out;
}
if(config_setting_type(member) != CONFIG_TYPE_STRING) {
fprintf(stderr, "Config Error: line %d: field \"%s\" should be a string\n",
config_setting_source_line(member), name);
goto err_out;
}
const char *tmp = config_setting_get_string(member);
if (!tmp && required) {
fprintf(stderr, "Config Error: line %d: empty required field \"%s\"\n",
config_setting_source_line(setting), name);
goto err_out;
}
if (!tmp) {
fprintf(stderr, "Config Warning: line %d: empty value for field \"%s\"\n",
config_setting_source_line(setting), name);
goto out;
}
*field = strdup(tmp);
if (*field == NULL) {
fprintf(stderr, "strdup failed: insufficient memory");
goto err_out;
}
out:
return 0;
err_out:
return -1;
}
static int parse_container_opts(config_t *config, struct manifest *manifest)
{
config_setting_t *copts = config_lookup(config, "container_opts");
config_setting_t *tmp;
if (!copts)
return -ENOENT;
tmp = config_setting_get_member(copts, "user");
if (tmp) {
manifest->copts.user = strdup(
config_setting_get_string(tmp));
if (!manifest->copts.user)
return -ENOMEM;
}
return 0;
}
VOID * GetOverrides(config_setting_t * group, char * ValueName)
{
char * ptr1;
char * MultiString = NULL;
char * ptr;
int Count = 0;
struct Override ** Value;
char * Val;
config_setting_t *setting;
Value = zalloc(4); // always NULL entry on end even if no values
Value[0] = NULL;
setting = config_setting_get_member (group, ValueName);
if (setting)
{
ptr = (char *)config_setting_get_string (setting);
while (ptr && strlen(ptr))
{
ptr1 = strchr(ptr, '|');
if (ptr1)
*(ptr1++) = 0;
Value = realloc(Value, (Count+2)*4);
Value[Count] = zalloc(sizeof(struct Override));
Val = strlop(ptr, ',');
if (Val == NULL)
break;
Value[Count]->Call = _strupr(_strdup(ptr));
Value[Count++]->Days = atoi(Val);
ptr = ptr1;
}
}
Value[Count] = NULL;
return Value;
}
int read_this_node_local_config(config_t * config)
{
const char * local_node_name;
config_setting_t * local_node_setting = config_lookup(config, "local_node");
if (local_node_setting == NULL)
{
message(LOG_ERROR, FACILITY_CONFIG, "Local node section is missing, please add it to local config.\n");
return CONFIG_FALSE;
}
config_setting_t * setting_node_id = config_setting_get_member(local_node_setting, "id");
config_setting_t * setting_node_name = config_setting_get_member(local_node_setting, "name");
if (setting_node_id == NULL || setting_node_name == NULL)
{
message(LOG_ERROR, FACILITY_CONFIG, "In local node section node name or node id are missing, please add them to local config.\n");
return CONFIG_FALSE;
}
if (config_setting_type(setting_node_id) != CONFIG_TYPE_INT)
{
message(LOG_ERROR, FACILITY_CONFIG, "In local node section key id has wrong type, it should be int.\n");
return CONFIG_FALSE;
}
if (config_setting_type(setting_node_name) != CONFIG_TYPE_STRING)
{
message(LOG_ERROR, FACILITY_CONFIG, "In local node section key name has wrong type, it should be string.\n");
return CONFIG_FALSE;
}
zfs_config.this_node.node_id = config_setting_get_int(setting_node_id);
local_node_name = config_setting_get_string(setting_node_name);
xmkstring(&(zfs_config.this_node.node_name), local_node_name);
/*read port configuration*/
zfs_config.this_node.host_port = read_tcp_port_setting(local_node_setting);
return CONFIG_TRUE;
}
static void get_value_libconfig(const config_setting_t *e, void *dest)
{
int type = config_setting_type(e);
switch (type) {
case CONFIG_TYPE_INT:
*(int *)dest = config_setting_get_int(e);
case CONFIG_TYPE_INT64:
*(long long *)dest = config_setting_get_int64(e);
break;
case CONFIG_TYPE_STRING:
dest = (void *)config_setting_get_string(e);
break;
case CONFIG_TYPE_BOOL:
*(int *)dest = config_setting_get_bool(e);
break;
case CONFIG_TYPE_FLOAT:
*(double *)dest = config_setting_get_float(e);
/* Do nothing, add if needed */
}
}
void config_setting_copy_elem(config_setting_t *parent, const config_setting_t *src)
{
config_setting_t *set = NULL;
if (config_setting_is_aggregate(src))
config_setting_copy_aggregate(parent, src);
else if (CONFIG_TYPE_INT == config_setting_type(src)) {
set = config_setting_set_int_elem(parent, -1, config_setting_get_int(src));
config_setting_set_format(set, src->format);
} else if (CONFIG_TYPE_INT64 == config_setting_type(src)) {
set = config_setting_set_int64_elem(parent, -1, config_setting_get_int64(src));
config_setting_set_format(set, src->format);
} else if (CONFIG_TYPE_FLOAT == config_setting_type(src)) {
config_setting_set_float_elem(parent, -1, config_setting_get_float(src));
} else if (CONFIG_TYPE_STRING == config_setting_type(src)) {
config_setting_set_string_elem(parent, -1, config_setting_get_string(src));
} else if (CONFIG_TYPE_BOOL == config_setting_type(src)) {
config_setting_set_bool_elem(parent, -1, config_setting_get_bool(src));
}
}
void event_operator_init(void) {
if(init == 1) {
return;
}
init = 1;
plua_init();
char path[PATH_MAX];
char *f = STRDUP(__FILE__);
struct dirent *file = NULL;
DIR *d = NULL;
struct stat s;
char *operator_root = OPERATOR_ROOT;
if(f == NULL) {
OUT_OF_MEMORY
}
config_setting_get_string("operators-root", 0, &operator_root);
if((d = opendir(operator_root))) {
while((file = readdir(d)) != NULL) {
memset(path, '\0', PATH_MAX);
sprintf(path, "%s%s", operator_root, file->d_name);
if(stat(path, &s) == 0) {
/* Check if file */
if(S_ISREG(s.st_mode)) {
if(strstr(file->d_name, ".lua") != NULL) {
plua_module_load(path, OPERATOR);
}
}
}
}
}
closedir(d);
FREE(f);
if(operator_root != (void *)OPERATOR_ROOT) {
FREE(operator_root);
}
}
/**
* Load string value from config.
* @param[in] section Config section.
* @param[in] option Option name.
* @param[out] pvalue Value pointer.
* @return <0 - error. 0 - success. >0 - not found.
*/
static int zcfg_load_string(const config_setting_t *option, char **pvalue)
{
*pvalue = NULL;
if (!option) {
return 1;
}
if (CONFIG_TYPE_STRING != option->type) {
return -1;
}
const char *str_val = config_setting_get_string(option);
if (NULL == str_val) {
return -1;
}
*pvalue = strdup(str_val);
return 0;
}
static void get_field_string_libconfig(config_setting_t *e, const char *path, void *dest, size_t n)
{
config_setting_t *elem;
const char *str;
if (path)
elem = config_setting_lookup(e, path);
else
elem = e;
if (!elem || config_setting_type(elem) != CONFIG_TYPE_STRING)
return;
if (path) {
if (config_setting_lookup_string(e, path, &str))
strncpy(dest, str, n);
} else {
if ((str = config_setting_get_string(e)) != NULL)
strncpy(dest, str, n);
}
}
/**
* Print a configuration setting.
* @param f File stream to print to
* @param cs Configuration setting
* @param d Current depth.
*/
static void config_setting_fprint(FILE *f, config_setting_t * cs, int d)
{
assert(cs && d >= 0);
int i;
for (i = 0; i < d; i++)
fprintf(f, " ");
char *n = config_setting_name(cs);
switch (config_setting_type(cs)) {
case CONFIG_TYPE_GROUP:
if (d > 0)
fprintf(f, "%s = {\n", n);
for (i = 0; i < config_setting_length(cs); i++)
config_setting_fprint(f, config_setting_get_elem(cs, i), d + 1);
if (d > 0) {
for (i = 0; i < d; i++)
fprintf(f, " ");
fprintf(f, "};\n");
}
break;
case CONFIG_TYPE_STRING:
fprintf(f, "%s\t= \"%s\";\n", n, config_setting_get_string(cs));
break;
case CONFIG_TYPE_FLOAT:
fprintf(f, "%s\t= %7.5f;\n", n, config_setting_get_float(cs));
break;
case CONFIG_TYPE_INT:
fprintf(f, "%s\t= %d;\n", n, config_setting_get_int(cs));
break;
default:
error("Unsupported type for configuration setting '%s'", n);
}
}
// {{{ session_get_user()
int session_get_user(const char *sessid, char *user, size_t len)
{
struct config_t cfg;
config_init(&cfg);
config_setting_t *cs;
config_setting_t *vs;
if(!config_read_file(&cfg, OD_SESSION_FILE))
return -1;
int i=0;
for(i=0; ;i++)
{
if( !(cs = config_setting_get_elem(cfg.root, i)) )
break;
if( !(vs = config_setting_get_member(cs, "sessid")) )
continue;
char *session_user = config_setting_name(cs);
if(!session_user)
continue;
const char *res = config_setting_get_string(vs);
if(res)
if(strcmp(res, sessid)==0)
{
sstrncpy(user, session_user, len);
config_destroy(&cfg);
return 0;
}
}
config_destroy(&cfg);
return -1;
}
static int parse_yum_opts(struct config_t *config, struct manifest *manifest)
{
if (!config || !manifest)
return -EINVAL;
config_setting_t *yum_opts = config_lookup(config, "yum_opts");
config_setting_t *releasever;
/*
* yum opts aren't required
*/
if (!yum_opts)
return 0;
releasever = config_setting_get_member(yum_opts, "releasever");
if (releasever) {
manifest->yum.releasever = strdup(
config_setting_get_string(releasever));
if (!manifest->yum.releasever)
return -ENOMEM;
}
return 0;
}
// ----------------------------------------------------------------------------------------
// Sistema Multilinguagem
// ----------------------------------------------------------------------------------------
// read_message("Grupo.SubGrupo.String");
// ----------------------------------------------------------------------------------------
// http://www.hyperrealm.com/libconfig/libconfig_manual.html
// ----------------------------------------------------------------------------------------
char *read_message(const char *param)
{
static char message[512];
config_setting_t *str;
config_t configLang;
config_init(&configLang);
if(!config_read_file(&configLang, (!strlen(bra_config.lang_file)?"conf/lang/pt_br.conf":bra_config.lang_file))) {
ShowError("read_message erro: %s:%d - %s\n", config_error_file(&configLang), config_error_line(&configLang), config_error_text(&configLang));
config_destroy(&configLang);
return "";
}
if(!(str = config_lookup(&configLang, param))) {
ShowError("read_message erro: %s\n", param);
config_destroy(&configLang);
return "";
}
strncpy(message, config_setting_get_string(str), sizeof(message));
config_destroy(&configLang);
return message;
}
FTM_RET FTM_DEBUG_configLoad(FTM_DEBUG_CFG_PTR pCfg, FTM_UINT8_PTR pFileName)
{
config_t xLibConfig;
config_setting_t *pSection;
config_setting_t *pSubSection;
config_setting_t *pField;
config_init(&xLibConfig);
if (config_read_file(&xLibConfig, pFileName) == CONFIG_FALSE)
{
return FTM_RET_INVALID_ARGUMENTS;
}
pSection = config_lookup(&xLibConfig, "DEBUG");
if (pSection != NULL)
{
pField = config_setting_get_member(pSection, "mode");
if (pField != NULL)
{
pCfg->ulMode = (FTM_UINT32)config_setting_get_int(pField);
}
pSubSection = config_setting_get_member(pSection, "trace");
if (pSubSection != NULL)
{
pField = config_setting_get_member(pSubSection, "path");
if (pField != NULL)
{
strncpy(pCfg->xTrace.pPath,
config_setting_get_string(pField),
sizeof(pCfg->xTrace.pPath) - 1);
}
pField = config_setting_get_member(pSubSection, "prefix");
if (pField != NULL)
{
strncpy(pCfg->xTrace.pPrefix,
config_setting_get_string(pField),
sizeof(pCfg->xTrace.pPath) - 1);
}
pField = config_setting_get_member(pSubSection, "to_file");
if (pField != NULL)
{
pCfg->xTrace.bToFile = (FTM_BOOL)config_setting_get_int(pField);
}
pField = config_setting_get_member(pSubSection, "print_line");
if (pField != NULL)
{
pCfg->xTrace.bLine = (FTM_BOOL)config_setting_get_int(pField);
}
}
pSubSection = config_setting_get_member(pSection, "error");
if (pSubSection != NULL)
{
pField = config_setting_get_member(pSubSection, "path");
if (pField != NULL)
{
strncpy(pCfg->xError.pPath,
config_setting_get_string(pField),
sizeof(pCfg->xError.pPath) - 1);
}
pField = config_setting_get_member(pSubSection, "prefix");
if (pField != NULL)
{
strncpy(pCfg->xError.pPrefix,
config_setting_get_string(pField),
sizeof(pCfg->xError.pPath) - 1);
}
pField = config_setting_get_member(pSubSection, "to_file");
if (pField != NULL)
{
pCfg->xError.bToFile = (FTM_BOOL)config_setting_get_int(pField);
}
pField = config_setting_get_member(pSubSection, "print_line");
if (pField != NULL)
{
pCfg->xError.bLine = (FTM_BOOL)config_setting_get_int(pField);
}
}
}
config_destroy(&xLibConfig);
return FTM_RET_OK;
}
/*********************
return RET_NOK on error
*********************/
ret_code_t entry_copy_config(config_setting_t * source, config_setting_t * dest)
{
config_setting_t * new_source;
config_setting_t * new_dest;
int index = -1;
int int_value;
long long long_value;
double double_value;
const char * string;
while((new_source=config_setting_get_elem(source,index+1))!= NULL ) {
index++;
if(config_setting_is_group(new_source)) {
if(!entry_copy_aggregate(new_source,dest,CONFIG_TYPE_GROUP)) {
return RET_NOK;
}
}
else if(config_setting_is_array(new_source)) {
if(!entry_copy_aggregate(new_source,dest,CONFIG_TYPE_ARRAY)) {
return RET_NOK;
}
}
else if(config_setting_is_list(new_source)) {
if(!entry_copy_aggregate(new_source,dest,CONFIG_TYPE_LIST)) {
return RET_NOK;
}
}
else {
switch(config_setting_type(new_source)) {
case CONFIG_TYPE_INT:
int_value = config_setting_get_int(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_INT);
config_setting_set_int(new_dest,int_value);
continue;
case CONFIG_TYPE_INT64:
long_value = config_setting_get_int64(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_INT64);
config_setting_set_int64(new_dest,long_value);
continue;
case CONFIG_TYPE_FLOAT:
double_value = config_setting_get_float(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_FLOAT);
config_setting_set_float(new_dest,double_value);
continue;
case CONFIG_TYPE_BOOL:
int_value = config_setting_get_bool(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_BOOL);
config_setting_set_bool(new_dest,int_value);
continue;
case CONFIG_TYPE_STRING:
string = config_setting_get_string(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_STRING);
config_setting_set_string(new_dest,string);
continue;
default:
return RET_NOK;
}
}
}
return RET_OK;
}
static int parse_packaging(struct config_t *config, struct manifest *manifest)
{
config_setting_t *pkg = config_lookup(config, "packaging");
config_setting_t *tmp;
int rc = -EINVAL;
if (!pkg) {
LOG(ERROR, "You must supply a packaging directive\n");
goto out;
}
rc = -ENOMEM;
tmp = config_setting_get_member(pkg, "name");
if (!tmp) {
LOG(ERROR, "You must specify a package name\n");
goto out;
}
manifest->package.name = strdup(config_setting_get_string(tmp));
if (!manifest->package.name)
goto out;
tmp = config_setting_get_member(pkg, "version");
if (!tmp) {
LOG(ERROR, "You must specify a package version\n");
goto out_free;
}
manifest->package.version = strdup(config_setting_get_string(tmp));
if (!manifest->package.version)
goto out_free;
tmp = config_setting_get_member(pkg, "release");
if (!tmp) {
LOG(ERROR, "You must specify a package release\n");
goto out_free;
}
manifest->package.release = strdup(config_setting_get_string(tmp));
if (!manifest->package.release)
goto out_free;
tmp = config_setting_get_member(pkg, "summary");
if (!tmp) {
LOG(ERROR, "You must specify a package summary\n");
goto out_free;
}
manifest->package.summary = strdup(config_setting_get_string(tmp));
if (!manifest->package.summary)
goto out_free;
tmp = config_setting_get_member(pkg, "license");
if (!tmp) {
LOG(ERROR, "You must specify a package license\n");
goto out_free;
}
manifest->package.license = strdup(config_setting_get_string(tmp));
if (!manifest->package.license)
goto out_free;
tmp = config_setting_get_member(pkg, "author");
if (!tmp) {
LOG(ERROR, "You must specify a package author\n");
goto out_free;
}
manifest->package.author = strdup(config_setting_get_string(tmp));
if (!manifest->package.author)
goto out_free;
tmp = config_setting_get_member(pkg, "post_script");
if (tmp) {
manifest->package.post_script =
strdup(config_setting_get_string(tmp));
if (!manifest->package.post_script)
goto out_free;
}
tmp = config_setting_get_member(pkg, "parent_container");
if (tmp)
manifest->package.parent_container =
strdup(config_setting_get_string(tmp));
rc = 0;
goto out;
out_free:
free(manifest->package.license);
free(manifest->package.summary);
free(manifest->package.release);
free(manifest->package.version);
free(manifest->package.author);
free(manifest->package.name);
free(manifest->package.post_script);
free(manifest->package.parent_container);
out:
return rc;
}
int load_memory(void) {
config_setting_t *pmemory;
config_setting_t *pblock;
config_setting_t *args;
config_setting_t *arg;
int memory_items = 0;
int arg_items = 0;
char *name;
const char *module;
hw_config_t *hw_config = NULL;
INFO("Loading memory");
pmemory = config_lookup(&main_config, "memory");
if(!pmemory) {
INFO("No memory blocks to laod");
return TRUE;
}
while(1) {
pblock = config_setting_get_elem(pmemory, memory_items);
memory_items++;
if(!pblock)
break;
name = config_setting_name(pblock);
INFO("Found memory element: %s", name);
if(!config_setting_lookup_string(pblock, "module", &module)) {
FATAL("Missing module entry for memory item %s", name);
exit(1);
}
INFO(" Module name: %s", module);
args = config_setting_get_member(pblock, "args");
if (!args) {
hw_config = malloc(sizeof(hw_config_t));
if (!hw_config) {
FATAL("malloc");
exit(1);
}
arg_items = 0;
} else {
arg_items = config_setting_length(args);
INFO(" %d arg items", arg_items);
hw_config = malloc(sizeof(hw_config_t) +
(arg_items * sizeof(hw_config_item_t)));
if(!hw_config) {
FATAL("malloc");
exit(1);
}
}
/* now walk the args and put them in a
config struct */
hw_config->config_items = arg_items;
for(int x = 0; x < arg_items; x++) {
arg = config_setting_get_elem(args, x);
const char *key = config_setting_name(arg);
if(!key) {
FATAL("Bad arg key in %s", name);
exit(1);
}
const char *value = NULL;
value = config_setting_get_string(arg);
if(!value) {
FATAL("Bad arg value for %s in %s",
key, name);
exit(1);
}
hw_config->item[x].key = key;
hw_config->item[x].value = value;
INFO(" %s => %s", key, value);
}
/* now, let's load it */
memory_load(name, module, hw_config);
if (hw_config) {
free(hw_config);
hw_config = NULL;
}
}
INFO("Memory loaded");
return TRUE;
}
const char *getStrConf(param_t param)
{
config_setting_t *setting = NULL;
const char *strsetting = NULL;
switch (param) {
case CERTIFICATE:
setting = config_lookup(&configuration, "certificate");
if (!setting)
return "/etc/umurmur/certificate.crt";
else {
if ((strsetting = config_setting_get_string(setting)) != NULL)
return strsetting;
else
return "/etc/umurmur/certificate.crt";
}
break;
case KEY:
setting = config_lookup(&configuration, "private_key");
if (!setting)
return "/etc/umurmur/private_key.key";
else {
if ((strsetting = config_setting_get_string(setting)) != NULL)
return strsetting;
else
return "/etc/umurmur/private_key.key";
}
break;
case CAPATH:
setting = config_lookup(&configuration, "ca_path");
if (!setting)
return NULL;
else {
if ((strsetting = config_setting_get_string(setting)) != NULL)
return strsetting;
else
return NULL;
}
break;
case PASSPHRASE:
setting = config_lookup(&configuration, "password");
if (!setting)
return "";
else {
if ((strsetting = config_setting_get_string(setting)) != NULL)
return strsetting;
else
return "";
}
break;
case ADMIN_PASSPHRASE:
setting = config_lookup(&configuration, "admin_password");
if (!setting)
return "";
else {
if ((strsetting = config_setting_get_string(setting)) != NULL)
return strsetting;
else
return "";
}
break;
case BINDADDR:
setting = config_lookup(&configuration, "bindaddr");
if (!setting)
return NULL;
else {
if ((strsetting = config_setting_get_string(setting)) != NULL)
return strsetting;
else
return NULL;
}
break;
case BINDADDR6:
setting = config_lookup(&configuration, "bindaddr6");
if (!setting)
return NULL;
else {
if ((strsetting = config_setting_get_string(setting)) != NULL)
return strsetting;
else
return NULL;
}
break;
case WELCOMETEXT:
setting = config_lookup(&configuration, "welcometext");
if (!setting)
return DEFAULT_WELCOME;
else {
if ((strsetting = config_setting_get_string(setting)) != NULL)
return strsetting;
else
return DEFAULT_WELCOME;
}
break;
case DEFAULT_CHANNEL:
setting = config_lookup(&configuration, "default_channel");
if (!setting)
return "";
else {
if ((strsetting = config_setting_get_string(setting)) != NULL)
return strsetting;
else
return "";
}
break;
case USERNAME:
setting = config_lookup(&configuration, "username");
if (!setting)
return "";
else {
if ((strsetting = config_setting_get_string(setting)) != NULL)
return strsetting;
else
return "";
}
break;
case GROUPNAME:
setting = config_lookup(&configuration, "groupname");
if (!setting)
return "";
else {
if ((strsetting = config_setting_get_string(setting)) != NULL)
return strsetting;
else
return "";
}
break;
case LOGFILE:
setting = config_lookup(&configuration, "logfile");
if (!setting)
return NULL;
else {
if ((strsetting = config_setting_get_string(setting)) != NULL)
return strsetting;
else
return NULL;
}
break;
case BANFILE:
setting = config_lookup(&configuration, "banfile");
if (!setting)
return NULL;
else {
if ((strsetting = config_setting_get_string(setting)) != NULL)
return strsetting;
else
return NULL;
}
break;
default:
doAssert(false);
break;
}
return NULL;
}
static void dx_reload_cfg()
{
int i, j;
const char *s;
config_setting_t *dxs = dxcfg_lookup("dx", CFG_REQUIRED);
assert(config_setting_type(dxs) == CONFIG_TYPE_LIST);
const config_setting_t *dxe;
for (i=0; (dxe = config_setting_get_elem(dxs, i)) != NULL; i++) {
assert(config_setting_type(dxe) == CONFIG_TYPE_GROUP);
}
int _dx_list_len = i-1;
lprintf("%d dx entries\n", _dx_list_len);
dx_t *_dx_list = (dx_t *) kiwi_malloc("dx_list", (_dx_list_len+1) * sizeof(dx_t));
float f = 0;
dx_t *dxp;
for (i=0, dxp = _dx_list; i < _dx_list_len; i++, dxp++) {
dxe = config_setting_get_elem(dxs, i);
config_setting_t *e;
assert((e = config_setting_get_member(dxe, "e")) != NULL);
assert(config_setting_type(e) == CONFIG_TYPE_LIST);
assert((dxp->freq = (float) config_setting_get_float_elem(e, 0)) != 0);
if (dxp->freq < f)
lprintf(">>>> DX: entry with freq %.2f < current freq %.2f\n", dxp->freq, f);
else
f = dxp->freq;
assert((s = config_setting_get_string_elem(e, 1)) != NULL);
dxcfg_mode(dxp, s);
assert((s = config_setting_get_string_elem(e, 2)) != NULL);
dxp->ident = str_encode((char *) s);
if ((s = config_setting_get_string_elem(e, 3)) == NULL) {
dxp->notes = NULL;
} else {
dxp->notes = str_encode((char *) s);
}
config_setting_t *flags;
const char *flag;
if ((flags = config_setting_get_member(dxe, "f")) != NULL) {
if (config_setting_type(flags) == CONFIG_TYPE_ARRAY) {
for (j=0; j < config_setting_length(flags); j++) {
assert((flag = config_setting_get_string_elem(flags, j)) != NULL);
dxcfg_flag(dxp, flag);
}
} else {
assert((flag = config_setting_get_string(flags)) != NULL);
dxcfg_flag(dxp, flag);
}
}
config_setting_t *offset;
if ((offset = config_setting_get_member(dxe, "o")) != NULL) {
if (config_setting_type(offset) == CONFIG_TYPE_ARRAY) {
assert((dxp->low_cut = (float) config_setting_get_int_elem(offset, 0)) != 0);
assert((dxp->high_cut = (float) config_setting_get_int_elem(offset, 1)) != 0);
} else {
assert((dxp->offset = (float) config_setting_get_int(offset)) != 0);
}
}
//printf("dxe %d f %.2f notes-%c off %.0f,%.0f\n", i, dxp->freq, dxp->notes? 'Y':'N', dxp->offset, dxp->high_cut);
}
switch_dx_list(_dx_list, _dx_list_len);
// convert to json
printf("### converting dx list to json\n");
dx_save_as_json();
}