int nodeup_setup(char *configfile) { /* initialize our new clean configuration to default values */ tc.fd = -1; tc.listen_path = strdup(DEFAULT_LISTENPATH); tc.worker = strdup(DEFAULT_WORKER); tc.max_clients = DEFAULT_MAXCLIENTS; tc.startup_delay = DEFAULT_STARTUPDELAY; tc.log_level = DEFAULT_LOGLEVEL; if (cmconf_process_file(configfile, configopts)) { config_free(&tc); return -1; } if (conf.listen_path && strcmp(tc.listen_path, conf.listen_path) == 0) { tc.fd = conf.fd; conf.fd = -1; } else { tc.fd = nodeup_setup_listen(tc.listen_path);\ } clients = realloc(clients, sizeof(int) * tc.max_clients); config_free(&conf); memcpy(&conf, &tc, sizeof(struct config_t)); return 0; }
int main(int argc, char *argv[]) { int ret; config.logFilePath = DEFAULT_LOG_FILE_PATH; config.logLevel = INFO_LOG; parse_cmd_line(argc, argv); ret = load_config(); if(ret) { log_message(ERROR_LOG, "Loading configuration failed."); config_free(); return 1; } ret = initialize(); if(ret != 0) { log_message(ERROR_LOG, "initialize is failed."); config_free(); return 1; } ret = socks_proxy(); cachemgr_fini(); log_fini(); config_free(); return 0; }
int server_start() { thread_state_t *state = NULL; struct sockaddr_in cli_addr; int cli_fd; socklen_t clilen = sizeof (cli_addr); /* Allocate new configuration */ if ((server_config = config_new()) == NULL) { ERROR_MSG("Internal error: Can not allocate configuration\n"); return 1; } /* Creating socket */ if ((server_config->socket_fd = create_server_socket(get_port())) < 0) { ERROR_MSG("Error: Can not create socket\n"); config_free(&server_config); return 1; } while (1) { cli_fd = accept(server_config->socket_fd, (struct sockaddr *)&cli_addr, &clilen); if (cli_fd < 0) { ERROR_MSG("ERROR on accept\n"); continue; } if (check_overload() < 0) { ERROR_MSG("ERROR close\n"); close(cli_fd); continue; } state = thread_state_new(); state->cli_fd = cli_fd; INCR_SERVER_LOAD; pthread_create(&(state->thread), NULL, compile_file, state); } config_free(&server_config); return 0; }
s32 ws__natpfHandWorkSyncSend(WS_ENV* soap, int *ret) { CURL *curl = NULL; struct hotb_config_s hotb_cfg; s8 url[256] = {0}; s8 name[256]={0}, passwd[256]={0}; CONFIG *cfg = NULL; int web_pro, web_port; char path[256]={0}; char * sid = web_session_id(); hotb_get_config(&hotb_cfg); sprintf(path, "/var/web/session/_%s", sid); if (NULL !=(cfg = config_load(path))) { strncpy(name, config_get(cfg, "name", ""), 255); strncpy(passwd, config_get(cfg, "password", ""), 255); config_free(cfg); cfg = NULL; } cfg = config_load(CURRENT_WEB_PROTOCOL); web_pro = config_getint(cfg, "web_http_srv", 1); if(web_pro == 1) { web_port = config_getint(cfg, "web_http_port", 80); snprintf(url, 255, "http://%s:%d/func/web_main/submit/hotbackup/handworksync?user_name=%s&password=%s&get=1", hotb_cfg.hotb_ip, web_port, name, passwd); } else { web_port = config_getint(cfg, "web_https_port", 443); snprintf(url, 255, "https://%s:%d/func/web_main/submit/hotbackup/handworksync?user_name=%s&password=%s&get=1", hotb_cfg.hotb_ip, web_port, name, passwd); } config_free(cfg); curl = curl_easy_init(); if (NULL == curl) { return ws_send_soap_error(soap, "Failed before sending configures!"); } curl_easy_setopt(curl, CURLOPT_URL, url); if (CURLE_OK != curl_easy_perform(curl)) { curl_easy_cleanup(curl); return ws_send_soap_error(soap, "Failed on sending configures!"); } DPF("path=[%s]\nurl=[%s]\n", path, url); curl_easy_cleanup(curl); return WS_OK; }
int main(int argc, const char **argv) { if (config_init(argc, argv)) return 1; if (xlib_init()) { config_free(); return 2; } xlib_mainloop(); xlib_free(0); config_free(); return 0; }
void config_dereference (config_t * conf) { #ifdef WITH_DEBUG char szDebug[300]; #endif os_mutex_lock (&conf->lock); conf->refcount--; if (conf->refcount == 0) { config_free (conf); os_mutex_unlock (&conf->lock); /* Ok, this happens outside the lock. But we know * nothing is using it, so it can't hurt. */ os_mutex_close (&conf->lock); free (conf); #ifdef WITH_DEBUG sprintf (szDebug, "Last reference to config %p, now destroyed", (void *) conf); DEBUG_LOG (szDebug); #endif } else { os_mutex_unlock (&conf->lock); } }
/******************************************************************************* 函数名称 : set_web_listen_global_conf 功能描述 : 设置web监听全局配置 输入参数 : global_conf 全局配置项 输出参数 : 无 返 回 值 : ERROR_SUCCESS 成功 ERROR_FAIL 失败 -------------------------------------------------------------------------------- 最近一次修改记录 : 修改作者 : 仇俊杰 修改目的 : 新添加函数 修改日期 : 2011-1-8 *******************************************************************************/ u32 set_web_listen_global_conf (web_listen_global_cfg * global_conf) { CONFIG * cfg = NULL; s8 user_group_str[USER_GROUP_STRING_LEN] = {0}; cfg = config_load(WEB_LISTEN_CFG_PATH); if (NULL == cfg) { return ERROR_FAIL; } strncpy(user_group_str, config_get(cfg, "user_group_string","1"), USER_GROUP_STRING_LEN - 1); user_group_str[USER_GROUP_STRING_LEN - 1] = 0; obj_quote_handle(user_group_str, NETADDR_DEL_REFER); cfg = config_setint(cfg, "set_enable", global_conf->enable); cfg = config_set(cfg, "user_group_string", global_conf->user_group); cfg = config_setint(cfg, "aged_time", global_conf->aged_time); cfg = config_set(cfg, "popwnd_url", global_conf->popwnd_url); cfg = config_setint(cfg, "pf_time", global_conf->pf_time); obj_quote_handle(global_conf->user_group, NETADDR_ADD_REFER); config_store(cfg, WEB_LISTEN_CFG_PATH); config_free(cfg); return ERROR_SUCCESS; }
static int table_redis_update(void) { struct config *c; if ((c = config_load(conffile)) == NULL) return (0); if (config_connect(c) == 0) { config_free(c); return (0); } config_free(config); config = c; return (1); }
/* FIXME doc */ static int client_preprocess() { if (preprocess(config->argc, config->argv)) { config_free(&config); return -1; } if (send_argv(config->socket_fd, config->argc, config->argv) < 0) { ERROR_MSG("Error: Can not send argv to the server\n"); close(config->socket_fd); return -1; } if (send_file(config->socket_fd, config->file->output_file) < 0) { ERROR_MSG("Error: Can not send file to the server\n"); close(config->socket_fd); return -1; } return 0; }
void test_min_realizations_percent(const char * num_realizations_str, const char * min_realizations_str, int min_realizations){ test_work_area_type * work_area = test_work_area_alloc("test_min_realizations"); { FILE * config_file_stream = util_mkdir_fopen("config_file", "w"); test_assert_not_NULL(config_file_stream); fprintf(config_file_stream, num_realizations_str); fprintf(config_file_stream, min_realizations_str); fclose(config_file_stream); config_type * c = config_alloc(); config_schema_item_type * item = config_add_schema_item(c , NUM_REALIZATIONS_KEY , true ); config_schema_item_set_default_type(item, CONFIG_INT); config_schema_item_set_argc_minmax( item , 1 , 1); item = config_add_schema_item(c , MIN_REALIZATIONS_KEY , false ); config_schema_item_set_argc_minmax( item , 1 , 2); test_assert_true(config_parse(c , "config_file" , "--" , NULL , NULL , false , true )); analysis_config_type * ac = create_analysis_config( ); analysis_config_init(ac, c); test_assert_int_equal( min_realizations , analysis_config_get_min_realisations( ac ) ); analysis_config_free( ac ); config_free( c ); } test_work_area_free(work_area); }
TEST_F(ConfigTest, config_remove_section) { config_t *config = config_new(CONFIG_FILE); EXPECT_TRUE(config_remove_section(config, "DID")); EXPECT_FALSE(config_has_section(config, "DID")); EXPECT_FALSE(config_has_key(config, "DID", "productId")); config_free(config); }
bool btc_config_init(void) { osi_mutex_new(&lock); config = config_new(CONFIG_FILE_PATH); if (!config) { LOG_WARN("%s unable to load config file; starting unconfigured.\n", __func__); config = config_new_empty(); if (!config) { LOG_ERROR("%s unable to allocate a config object.\n", __func__); goto error; } } if (config_save(config, CONFIG_FILE_PATH)) { // unlink(LEGACY_CONFIG_FILE_PATH); } return true; error:; config_free(config); osi_mutex_free(&lock); config = NULL; LOG_ERROR("%s failed\n", __func__); return false; }
/******************************************************************************* 函数名称 : ws__setDomainListenConfig 功能描述 : 保存域监听的相关配置 输入参数 : WS_ENV * ws_env web services环境 int domainListenSwitch 域监听开关 int agedTime 老化时间 输出参数 : int *ret 设置结果 返 回 值 : WS_OK 成功 -------------------------------------------------------------------------------- 最近一次修改记录 : 修改作者 : 张岳 修改目的 : 新函数 修改日期 : 2013年1月6日 *******************************************************************************/ s32 ws__setDomainListenConfig(WS_ENV* ws_env, int domainListenSwitch, int agedTime, int *ret) { CONFIG *cfg = NULL; domain_listen_cfg listen_cfg; u32 res = ERROR_SUCCESS; cfg = config_load(DOMAIN_LISTEN_CFG_PATH); if (NULL == cfg) { return ERROR_FAIL; } /*域监听设置写入配置文件中*/ cfg = config_setint(cfg, "switch", domainListenSwitch); cfg = config_setint(cfg, "aged_time", agedTime); config_store(cfg, DOMAIN_LISTEN_CFG_PATH); config_free(cfg); listen_cfg.domain_listen_switch = domainListenSwitch; listen_cfg.aged_time = agedTime; /*下发到数据面*/ res = webauth_syscall_set_domain_listen_config(listen_cfg); if(ERROR_SUCCESS != res) { return ws_new_soap_fault(ws_env, ERROR_SYSTEM); } *ret = 0; return WS_OK; }
int main(int argc, char **argv) { config_load(&config, argc, argv); for(int i = optind; i < argc; ++i) { printf("option: %s\n", argv[i]); } config_free(&config); }
void teardown(void) { auth_disconnect(); db_disconnect(); config_free(); g_mime_shutdown(); }
TEST_F(ConfigTest, config_no_bad_keys) { config_t *config = config_new(CONFIG_FILE); EXPECT_FALSE(config_has_key(config, "DID_BAD", "primaryRecord")); EXPECT_FALSE(config_has_key(config, "DID", "primaryRecord_BAD")); EXPECT_FALSE(config_has_key(config, CONFIG_DEFAULT_SECTION, "primaryRecord")); config_free(config); }
void teardown(void) { auth_disconnect(); db_disconnect(); config_free(); mempool_close(&queue_pool); }
/******************************************************************************* 函数名称 : ws__getArpExploreInfo 功能描述 : 获取ARP探测周期配置信息 输入参数 : ws_env ---- web service执行环境 输出参数 : 无 返 回 值 : WS_OK ---- 执行成功 soapFault ---- 执行失败 -------------------------------------------------------------------------------- 最近一次修改记录 : 修改作者 : lishushu 修改目的 : 新添加函数 修改日期 : 2012-12-07 *******************************************************************************/ s32 ws__getArpExploreInfo(WS_ENV* ws_env, struct ws__getArpExploreInfoResponse *ret) { CONFIG *cfg = config_load(CONPLAT_CONF"/arp_probes_conf.conf"); (void)ws_env; ret->ret.openreqarp = 0; ret->ret.closearp = 0; ret->ret.oldtime = 600; ret->ret.retranstime = 5; ret->ret.explorecount = 6; ret->ret.vsmbondopt = 0; if (NULL != cfg) { ret->ret.openreqarp = config_getint(cfg, "close_req_arp_learning", ret->ret.openreqarp); ret->ret.closearp = config_getint(cfg,"close_arp", ret->ret.closearp); ret->ret.oldtime = config_getint(cfg, "reachable_time", ret->ret.oldtime); ret->ret.retranstime = config_getint(cfg, "retrans_time", ret->ret.retranstime); ret->ret.explorecount = config_getint(cfg, "probes", ret->ret.explorecount); ret->ret.vsmbondopt = config_getint(cfg, "vsmbondopt", ret->ret.vsmbondopt); } config_free(cfg); return WS_OK; }
/* * This is the main global destructor for the app. Call this after * _all_ libcurl usage is done. */ static void main_free(struct GlobalConfig *config) { /* Cleanup the easy handle */ curl_easy_cleanup(config->easy); config->easy = NULL; /* Main cleanup */ curl_global_cleanup(); convert_cleanup(); metalink_cleanup(); #ifdef USE_NSS if(PR_Initialized()) { /* prevent valgrind from reporting still reachable mem from NSRP arenas */ PL_ArenaFinish(); /* prevent valgrind from reporting possibly lost memory (fd cache, ...) */ PR_Cleanup(); } #endif free_config_fields(config); /* Free the config structures */ config_free(config->last); config->first = NULL; config->last = NULL; }
config_t *config_new(const char *filename) { assert(filename != NULL); config_t *config = config_new_empty(); if (!config) { return NULL; } esp_err_t err; nvs_handle fp; err = nvs_open(filename, NVS_READWRITE, &fp); if (err != ESP_OK) { if (err == ESP_ERR_NVS_NOT_INITIALIZED) { LOG_ERROR("%s: NVS not initialized. " "Call nvs_flash_init before initializing bluetooth.", __func__); } else { LOG_ERROR("%s unable to open NVS namespace '%s'\n", __func__, filename); } config_free(config); return NULL; } config_parse(fp, config); nvs_close(fp); return config; }
/***************************************************************************** 函 数 名 : ws__setLocalUserInfoSync 功能描述 : 本地用户远程同步 输入参数 : soap ---- web service执行环境 输出参数 : ret ---- 返回结果 返 回 值 : WS_OK ---- 执行成功 ---------------------------------------------------------------------------- ---- 最近一次修改记录 : 修改作者 : 仇俊杰 修改目的 : 新添加函数 修改日期 : 2011-2-22 *****************************************************************************/ int ws__setLocalUserInfoSync(WS_ENV * ws_env, char * umcIp, int umcPort, char * userInfo, int * ret) { CONFIG *cfg; s8 *delim = "?"; s8 send_umc[LOCAL_USER_SEND_UMC_LENGTH]; s8 *user_info = NULL; s8 *user_info_tmp = NULL; cfg = config_load(LOCAL_USER_CFG_PATH); if(NULL == cfg) { return ws_send_soap_error (ws_env, "Open file failed!"); } cfg = config_set(cfg, "umc_ip", umcIp); cfg = config_setint(cfg, "umc_port", umcPort); config_store(cfg, LOCAL_USER_CFG_PATH); config_free(cfg); sprintf(send_umc, " curl http://%s:%d/UMC/sys/sub/OrgManageDevcieadd.action? --data-urlencode \"user=%s\"" , umcIp, umcPort, strtok(userInfo, delim)); user_info = ws_malloc(ws_env, LOCAL_USER_INFO_LEN); user_info_tmp = ws_malloc(ws_env, LOCAL_USER_INFO_LEN); while((user_info = strtok(NULL, delim))) { sprintf(user_info_tmp, " --data-urlencode \"user=%s\"", user_info); strcat(send_umc, user_info_tmp); } system(send_umc); return WS_OK; }
/******************************************************************************* 函数名称 : portal_auth_set_basic_cfg 功能描述 : 设置portal认证基本配置 输入参数 : global_conf ---- portal认证基本配置 输出参数 : 无 返 回 值 : PORTAL_SUCCESS: 成功 -------------------------------------------------------------------------------- 最近一次修改记录 : 修改作者 : 仇俊杰 修改目的 : 新添加函数 修改日期 : 2011-5-10 *****************************************************************************/ u32 portal_set_basic_cfg (portal_basic_cfg_s * global_conf) { CONFIG * cfg = NULL; cfg = config_load(PORTAL_AUTH_CFG_PATH); if (NULL == cfg) { return PORTAL_OPEN_FILE_FAIL; } cfg = config_setint(cfg, "webauth_switch", global_conf->webauth_switch); cfg = config_setint(cfg, "client_switch", global_conf->client_switch); cfg = config_setint(cfg, "aged_time", global_conf->aged_time); cfg = config_setint(cfg, "auth_method", global_conf->auth_method); cfg = config_setint(cfg, "unique_auth", global_conf->every_auth); cfg = config_setint(cfg, "q_offline", global_conf->q_offline); cfg = config_setint(cfg, "radius_acct", global_conf->radius_acct); cfg = config_setint(cfg, "heartbeat_time", global_conf->heartbeat_time); /*将基本配置写入文件*/ config_store(cfg, PORTAL_AUTH_CFG_PATH); config_free(cfg); /*写入pam默认配置文件*/ if (WEBAUTH_ENABLE == global_conf->webauth_switch || PORTAL_CLIENT_AUTH_ENABLE == global_conf->client_switch) { webauth_set_pam_config(global_conf->auth_method); } return PORTAL_SUCCESS; }
/***************************************************************************** 函 数 名 : ws__setDnsmasq 功能描述 : 防火墙设备:配置Dnsmasq 输入参数 : ws_env ---- web service执行环境 dnsmasq ---- 是否启用DNS代理:dnsmasq 输出参数 : result ---- 返回结果 返 回 值 : ERR_OK ---- 执行成功 ws_new_soap_fault---- 执行失败 ----------------------------------------------------------------------------- 最近一次修改记录: 修改作者: zhangjiefeng 修改目的: 生成新函数 修改日期: 2010年01月19日 *****************************************************************************/ int ws__setDnsmasq(WS_ENV* ws_env, xsd__int dnsmasq, xsd__int* ret) { s32 result = ERROR_SUCCESS; s8 *value = NULL; CONFIG * cfg = NULL; if(1 == dnsmasq) { result = startdnsmasq(); value = "enable"; if(ERROR_SUCCESS != result) return ws_send_soap_error(ws_env, "Start dnsmasq failed."); } else if(0 == dnsmasq) { result = stopdnsmasq(); value = "disable"; if(ERROR_SUCCESS != result) return ws_send_soap_error(ws_env, "Stop dnsmasq failed."); } cfg = config_load(CFG_DNS_PATH); if(NULL == cfg) { return ws_send_soap_error(ws_env, "Open dns config file failed."); } cfg = config_setint(cfg, "dnsmasq_switch", dnsmasq); config_store(cfg, CFG_DNS_PATH); config_free(cfg); *ret = 0; return WS_OK; }
TEST_F(ConfigTest, config_remove_key_missing) { config_t *config = config_new(CONFIG_FILE); EXPECT_EQ(config_get_int(config, "DID", "productId", 999), 0x1200); EXPECT_TRUE(config_remove_key(config, "DID", "productId")); EXPECT_EQ(config_get_int(config, "DID", "productId", 999), 999); config_free(config); }
static int wallet_save_keys(struct wallet *wallet) { struct config *cfg; int res; int n; n = hashtable_getnumentries(wallet->hash_keys); Log(LGPFX" saving %u key%s in %sencrypted wallet %s.\n", n, n > 1 ? "s" : "", wallet->pass ? "encrypted" : "NON-", wallet->filename); cfg = config_create(); config_setint64(cfg, n, "numKeys"); if (wallet->pass) { char saltStr[80]; int64 count = 0; bool s; res = RAND_bytes(wallet->ckey->salt, sizeof wallet->ckey->salt); if (res != 1) { res = ERR_get_error(); Log(LGPFX" RAND_bytes failed: %d\n", res); goto exit; } str_snprintf_bytes(saltStr, sizeof saltStr, NULL, wallet->ckey->salt, sizeof wallet->ckey->salt); config_setstring(cfg, saltStr, "encryption.salt"); s = crypt_set_key_from_passphrase(wallet->pass, wallet->ckey, &count); ASSERT(s); ASSERT(count >= CRYPT_NUM_ITERATIONS_OLD); config_setint64(cfg, count, "encryption.numIterations"); } hashtable_for_each(wallet->hash_keys, wallet_save_key_cb, cfg); file_rotate(wallet->filename, 1); res = file_create(wallet->filename); if (res) { Log(LGPFX" failed to create file '%s': %s\n", wallet->filename, strerror(res)); goto exit; } res = file_chmod(wallet->filename, 0600); if (res) { Log(LGPFX" failed to chmod 0600 wallet.dat: %s\n", strerror(res)); goto exit; } res = config_write(cfg, wallet->filename); exit: config_free(cfg); return res; }
/* ARGSUSED */ static void signal_terminate(int sig) { detach_modes(); config_free(); exit(EXIT_SUCCESS); }
static void free_module(MODULE *mod) { free(mod->instance); free(mod->file); config_free(mod->ini); if(mod->dlh) dlclose(mod->dlh); free(mod); }
TEST_F(ConfigTest, config_section_end) { config_t *config = config_new(CONFIG_FILE); const config_section_node_t * section = config_section_begin(config); section = config_section_next(section); section = config_section_next(section); EXPECT_EQ(section, config_section_end(config)); config_free(config); }
static int table_postgres_update(void) { struct config *c; if ((c = config_load(conffile)) == NULL) return 0; if (config_connect(c) == 0) { config_free(c); return 0; } config_free(config); config = c; return 1; }
TEST_F(ConfigTest, config_has_keys) { config_t *config = config_new(CONFIG_FILE); EXPECT_TRUE(config_has_key(config, "DID", "recordNumber")); EXPECT_TRUE(config_has_key(config, "DID", "primaryRecord")); EXPECT_TRUE(config_has_key(config, "DID", "productId")); EXPECT_TRUE(config_has_key(config, "DID", "version")); config_free(config); }