int main(void)
{
cfg_t *acfg, *bcfg;
cfg_t *sec;
acfg = create_config();
fail_unless(cfg_parse(acfg, SRC_DIR "/a.conf") == 0);
bcfg = create_config();
fail_unless(cfg_parse(bcfg, SRC_DIR "/b.conf") == 0);
sec = cfg_getnsec(acfg, "sec", 0);
fail_unless(sec != 0);
fail_unless(cfg_size(acfg, "sec") == 1);
fail_unless(strcmp(cfg_title(sec), "acfg") == 0);
fail_unless(cfg_getint(sec, "a") == 5);
fail_unless(cfg_getint(sec, "b") == 2);
sec = cfg_getnsec(bcfg, "sec", 0);
fail_unless(sec != 0);
fail_unless(cfg_size(bcfg, "sec") == 1);
fail_unless(strcmp(cfg_title(sec), "bcfg") == 0);
fail_unless(cfg_getint(sec, "a") == 1);
fail_unless(cfg_getint(sec, "b") == 9);
cfg_free(acfg);
cfg_free(bcfg);
return 0;
}
bool SyncLogger::ParseFile(const char* pszHash)
{
if (strcmp(m_szCurShare, pszHash) == 0)
{
// File is currently parsed, there is no need to parse it again.
return true;
}
cfg_opt_t modEntry[] =
{
// Parses within the group.
CFG_STR(FILE_PATH_VARNAME, FILE_PATH_DEFAULT, CFGF_NONE),
CFG_STR(MOD_TIME_VARNAME, MOD_TIME_DEFAULT, CFGF_NONE),
CFG_STR(MOD_TYPE_VARNAME, MOD_TYPE_DEFAULT, CFGF_NONE),
CFG_END()
};
cfg_opt_t entries[] =
{
// Parses the single groups.
CFG_SEC(MOD_NUMBER_VARNAME, modEntry, CFGF_TITLE | CFGF_MULTI),
CFG_END()
};
// Initializes the parser.
m_pCFG = cfg_init(entries, CFGF_NONE);
// Parses the file.
char szLogName[MAX_PATH];
CalcLogFileName(pszHash, szLogName);
if (cfg_parse(m_pCFG, szLogName) == CFG_PARSE_ERROR)
return false;
return true;
}
int read_config(const char *filename, section_t &config)
{
static const char *funcname = "conf::read_config";
section_ptrs ptrs;
build_section(&config, ptrs);
cfg_t *cfg = cfg_init(ptrs[0].get(), CFGF_NONE);
cfg_set_error_function(cfg, cfg_error_fnc);
switch(cfg_parse(cfg, filename))
{
case CFG_FILE_ERROR:
throw logging::error(funcname, "Configuration file '%s' cannot be read: %s", filename, strerror(errno));
case CFG_PARSE_ERROR:
throw logging::error(funcname, "Errors were encountered during config reading.");
default:
throw logging::error(funcname, "cfg_parse() returned unexpected value");
case CFG_SUCCESS: break;
}
std::stringstream errors;
read_cfg_section(&config, cfg, errors);
cfg_free(cfg);
errors.peek();
if (!errors.eof())
{
for (std::string line; getline(errors, line); )
logger.log_message(LOG_ERR, funcname, line.c_str());
return 0;
}
return 1;
}
cfg_t *parse_conf(char *conf)
{
cfg_opt_t provider_opts[] = {
CFG_STR ("username", 0, CFGF_NONE),
CFG_STR ("password", 0, CFGF_NONE),
CFG_STR_LIST("alias", 0, CFGF_NONE),
CFG_END()
};
cfg_opt_t opts[] = {
CFG_BOOL("syslog", cfg_false, CFGF_NONE),
CFG_BOOL("wildcard", cfg_false, CFGF_NONE),
CFG_STR ("bind", 0, CFGF_NONE),
CFG_INT ("period", 60, CFGF_NONE),
CFG_INT ("startup-delay", 0, CFGF_NONE),
CFG_INT ("forced-update", 720000, CFGF_NONE),
CFG_SEC ("provider", provider_opts, CFGF_MULTI | CFGF_TITLE),
CFG_END()
};
cfg_t *cfg = cfg_init(opts, CFGF_NONE);
switch (cfg_parse(cfg, conf)) {
case CFG_FILE_ERROR:
fprintf(stderr, "Cannot read configuration file %s: %s\n", conf, strerror(errno));
case CFG_PARSE_ERROR:
return NULL;
case CFG_SUCCESS:
break;
}
return cfg;
}
cfg_t *parse_conf(const char *filename)
{
cfg_opt_t process_opts[] = {
CFG_STR("comm", 0, CFGF_NODEFAULT),
CFG_STR("args", 0, CFGF_NODEFAULT),
CFG_STR("pre", 0, CFGF_NONE),
CFG_END()
};
cfg_opt_t opts[] = {
CFG_SEC("process", process_opts, CFGF_MULTI | CFGF_TITLE),
CFG_INT("frequency", 10, CFGF_NONE),
CFG_END()
};
cfg_t *cfg = cfg_init(opts, CFGF_NONE);
//cfg_set_validate_func(cfg, "bookmark|port", conf_validate_port);
//cfg_set_validate_func(cfg, "bookmark", conf_validate_bookmark);
switch(cfg_parse(cfg, filename))
{
case CFG_FILE_ERROR:
printf("warning: configuration file '%s' could not be read: %s\n",
filename, strerror(errno));
printf("continuing with default values...\n\n");
case CFG_SUCCESS:
break;
case CFG_PARSE_ERROR:
return 0;
}
return cfg;
}
/*
Function to parse the server config file.
@param Config file location in the file system.
@param Struct to write results into.
@return -1 on failure, 0 on success.
*/
int parse_config(char * config_file, struct config_struct * running_config)
{
print_to_log("Parsing config file", LOG_INFO);
cfg_opt_t opts[] =
{
CFG_STR("domain", "", CFGF_NONE),
CFG_INT("connection_timeout_in_seconds", 0, CFGF_NONE),
CFG_INT("max_connections", 0, CFGF_NONE),
CFG_END()
};
cfg_t *cfg;
cfg = cfg_init(opts, CFGF_NONE);
if(cfg_parse(cfg, config_file) == CFG_PARSE_ERROR)
{
printf("Reading config %s has failed\n", config_file);
return -1;
}
if (strcmp(cfg_getstr(cfg, "domain"),"")!=0)
{
//Load domain into struct here.
}
if (cfg_getint(cfg, "connection_timeout_in_seconds")<=60)
{
//load connection_timeout_in_seconds into struct here.
running_config->connection_timeout_in_seconds = cfg_getint(cfg, "connection_timeout_in_seconds");
}
if (cfg_getint(cfg, "max_connections")<=1000)
{
//load connection_timeout_in_seconds into struct here.
running_config->max_connections = cfg_getint(cfg, "max_connections");
}
return 0;
}
void read_config(void)
{
static cfg_opt_t arg_opts[] = {
CFG_STR("value", "default", CFGF_NONE),
CFG_END()
};
cfg_opt_t opts[] = {
CFG_INT("delay", 3, CFGF_NONE),
CFG_STR("message", "This is a message", CFGF_NONE),
CFG_SEC("argument", arg_opts, CFGF_MULTI | CFGF_TITLE),
CFG_END()
};
char *buf = "" \
" delay = 3\n" \
"# message = \"asdfasfasfd tersf\"\n" \
" argument one { value = 1 }\n" \
" argument two { value=foo}\n";
cfg_free(cfg);
cfg = cfg_init(opts, 0);
cfg_parse_buf(cfg, buf);
cfg_parse(cfg, config_filename);
}
int parse_script(char *filename, script_ent_t * script) {
cfg_t *pcfg;
int i;
memset(script, 0, sizeof(script_ent_t));
printf("eins\n");
pcfg = cfg_init(script_opts, CFGF_NONE);
printf("zwei\n");
if (cfg_parse(pcfg, filename) == CFG_PARSE_ERROR)
return -1;
strcpy(script->name, cfg_getstr(pcfg, "name")); /* max 28 chars !!! */
strcpy(script->org_name, cfg_getstr(pcfg, "org_name")); /* max 64 chars !!! */
strcpy(script->comment, cfg_getstr(pcfg, "comment")); /* max 128 chars !!! */
script->script_num = cfg_getint(pcfg, "id");
script->version = cfg_getint(pcfg, "version");
script->unused1 = cfg_getint(pcfg, "unused1");
script->script_length = cfg_size(pcfg, "script");
if (script->script_length & 1) {
printf("WARNING: odd number of bytes in script ... truncating\n");
}
script->script_length >>= 1;
for (i = 0; i < (script->script_length << 1); i++)
script->script[i] = (uint8_t) cfg_getnint(pcfg, "script", i);
cfg_free(pcfg);
return 0;
}
/**
* Start up the configuration system, using the configuration file given
* to get the current values. If the configuration file given does not exist,
* go ahead and write out the default config to the file.
*/
gint config_init (const gchar *config_file)
{
gint ret = 0;
tc = cfg_init (config_opts, 0);
if (g_file_test (config_file,
G_FILE_TEST_IS_REGULAR))
{
/* Read in the existing configuration options */
ret = cfg_parse (tc, config_file);
if (ret == CFG_PARSE_ERROR) {
DEBUG_ERROR ("Problem parsing config");
g_printerr (_("Problem when opening config file\n"));
return 1;
} else if (ret != CFG_SUCCESS) {
DEBUG_ERROR ("Problem parsing config.");
g_printerr (_("An unexpected error occured while "
"parsing the config file\n"));
}
}
#ifndef NO_THREADSAFE
g_mutex_init(&mutex);
#endif
return 0;
}
/**
* Start up the configuration system, using the configuration file given
* to get the current values. If the configuration file given does not exist,
* go ahead and write out the default config to the file.
*/
gint config_init (const gchar *config_file)
{
gint ret = 0;
tc = cfg_init (config_opts, 0);
/* I know that this is racy, but I can't think of a good
* way to fix it ... */
if (g_file_test (config_file, G_FILE_TEST_IS_REGULAR)) {
/* Read the file, and try to upgrade it */
ret = cfg_parse (tc, config_file);
if (ret == CFG_SUCCESS)
try_to_update_config_file (config_file);
else {
DEBUG_ERROR ("Problem parsing config");
g_printerr (_("Problem parsing config file\n"));
return 1;
}
}
/* This is commented out because we don't want to do this. Basically, there
* is no need to write the config until we have shown the wizard, which is
* automatically shown on the first run. */
#if 0
else {
/* Write out the defaults */
config_write (config_file);
}
#endif
return 0;
}
db_info * get_db_info(const char * filename){
cfg_opt_t * opts = get_opt();
cfg_t *cfg;
cfg = cfg_init(opts, CFGF_NONE);
cfg_parse(cfg, filename);
db_info * info;
info = (db_info*)malloc(sizeof(db_info));
char * user = cfg_getstr(cfg, "user");
char * password = cfg_getstr(cfg,"password");
char * dbname = cfg_getstr(cfg,"dbname");
char * ip = cfg_getstr(cfg,"ip");
info->user = (char*)malloc(strlen(user)*sizeof(char));
info->password = (char*)malloc(strlen(user)*sizeof(char));
info->dbname = (char*)malloc(strlen(user)*sizeof(char));
info->ip = (char*)malloc(strlen(user)*sizeof(char));
strcpy(info->user,user);
strcpy(info->password,password);
strcpy(info->dbname,dbname);
strcpy(info->ip,ip);
info->port = cfg_getint(cfg,"port");
cfg_free(cfg);
return info;
}
static void conf_read(const char *path, int must)
{
int err;
DBG(1, "Reading configfile %s...\n", path);
if (access(path, R_OK) != 0) {
if (must)
quit("Error: Unable to read configfile \"%s\": %s\n",
path, strerror(errno));
else
return;
}
err = cfg_parse(cfg, path);
if (err == CFG_FILE_ERROR) {
quit("Error while reading configfile \"%s\": %s\n",
path, strerror(errno));
} else if (err == CFG_PARSE_ERROR) {
quit("Error while reading configfile \"%s\": parse error\n",
path);
}
configfile_read_units();
configfile_read_history();
configfile_read_attrs();
configfile_read_element_cfg();
}
int cfg_load(void)
{
char *p = game_cfg_path();
if (!p)
return -1;
if (access(p, R_OK))
return 0;
return cfg_parse(p);
}
//
// E_ParseEDFFile
//
// Parses the specified file.
//
static void E_ParseEDFFile(cfg_t *cfg, const char *filename)
{
int err;
if((err = cfg_parse(cfg, filename)))
{
E_EDFLoggedErr(1,
"E_ParseEDFFile: failed to parse %s (code %d)\n",
filename, err);
}
}
void get_db_query(const char * filename, char * query){
cfg_opt_t * opts = get_opt();
cfg_t *cfg;
cfg = cfg_init(opts, CFGF_NONE);
cfg_parse(cfg, filename);
strcpy(query,cfg_getstr(cfg, "db_query"));
free(cfg);
}
void get_model_filename(const char * filename, char * model_filename){
cfg_opt_t * opts = get_opt();
cfg_t *cfg;
cfg = cfg_init(opts, CFGF_NONE);
cfg_parse(cfg, filename);
strcpy(model_filename ,cfg_getstr(cfg, "model_filename"));
free(cfg);
}
/**
* Start up the configuration system, using the configuration file given
* to get the current values. If the configuration file given does not exist,
* go ahead and write out the default config to the file.
*/
gint config_init (const gchar *config_file)
{
gint ret = 0;
// Can we use a more descriptive name than tc?
tc = cfg_init (config_opts, 0);
if (g_file_test (config_file,
G_FILE_TEST_IS_REGULAR))
{
/* Read in the existing configuration options */
ret = cfg_parse (tc, config_file);
if (ret == CFG_PARSE_ERROR) {
DEBUG_ERROR ("Problem parsing config");
return ret;
} else if (ret != CFG_SUCCESS) {
DEBUG_ERROR ("Problem parsing config.");
return ret;
}
}
/* Deprecate old config settings
* This is a lame work around until we get a permenant solution to
* libconfuse lacking for this functionality
*/
const gchar *deprecated_tilda_config_options[] = {"show_on_monitor_number"};
remove_deprecated_config_options(deprecated_tilda_config_options, G_N_ELEMENTS(deprecated_tilda_config_options));
#if VTE_MINOR_VERSION >= 40
/* Deprecate old config settings
* This is a lame work around until we get a permenant solution to
* libconfuse lacking for this functionality
*/
const gchar *deprecated_vte_config_options[] = {"word_chars", "image", "scroll_background", "use_image"};
remove_deprecated_config_options (deprecated_vte_config_options, G_N_ELEMENTS(deprecated_vte_config_options));
#else
if (cfg_getopt(tc, "use_image")->nvalues < 1) {
cfg_setbool(tc, "use_image", FALSE);
}
if (cfg_getopt(tc, "word_chars")->nvalues < 1) {
cfg_setstr(tc, "word_chars", DEFAULT_WORD_CHARS);
}
if (cfg_getopt(tc, "scroll_background")->nvalues < 1) {
cfg_setbool(tc, "scroll_background", TRUE);
}
#endif
#ifndef NO_THREADSAFE
g_mutex_init(&mutex);
#endif
return ret;
}
static void transfer_params(char *config_file)
{
int n;
char *bitmap_file, *opt;
char *cp;
int cfd;
cfg_bitmap_only(); /* disable everything but cf_bitmap */
cfd = cfg_open(config_file);
if (verbose >= 3) printf("cfg_open returns: %d\n", cfd);
n = cfg_parse(cf_bitmap);
if (verbose >= 3) printf("cfg_parse returns: %d\n", n);
if (n != 0) {
die("Illegal token in '%s'", config_file);
}
if ((bitmap_file = cfg_get_strg(cf_bitmap, "bitmap")) != NULL) {
opt = "Using";
cp = strrchr(config_file, '/');
if (cp && bitmap_file[0] != '/') {
*++cp = 0;
bitmap_file = strcat(strcpy(alloc(strlen(config_file) + strlen(bitmap_file) + 1),
config_file),
bitmap_file);
*cp = '/';
}
} else {
opt = "Assuming";
cp = strrchr(config_file, '.');
if (cp) *cp = 0;
bitmap_file = alloc(strlen(config_file) + strlen(BMP_BMP) + 1);
strcpy(bitmap_file, config_file);
strcat(bitmap_file, BMP_BMP);
if (cp) *cp = '.';
}
printf("Transfer parameters from '%s' to '%s'", config_file, bitmap_file);
if (yesno("?", 0)==0) exit(0);
if (verbose > 0) printf("%s bitmap file: %s\n", opt, bitmap_file);
bmp_file_open(bitmap_file);
bmp_do_table(cfg_get_strg(cf_bitmap, "bmp-table"), menu);
bmp_do_colors(cfg_get_strg(cf_bitmap, "bmp-colors"), menu);
bmp_do_timer(cfg_get_strg(cf_bitmap, "bmp-timer"), menu);
bmp_file_close(1); /* update */
exit(0);
}
void load_config(god_t* god){
check_dirs();
char *home_dir = getenv("HOME");
char *conf_file = "/.local/share/crunchball/crunchball.cfg";
char tmp_path[500] = {0};
cp_str(tmp_path, home_dir);
cat_to_str(tmp_path, conf_file);
long int video_mode;
long int audio_level;
long int fullscreen;
long int high_score;
cfg_opt_t opts[] = {
CFG_SIMPLE_INT("video_mode", &video_mode),
CFG_SIMPLE_INT("audio_level", &audio_level),
CFG_SIMPLE_INT("fullscreen", &fullscreen),
CFG_SIMPLE_INT("high_score", &high_score),
CFG_END()
};
cfg_t *cfg;
cfg = cfg_init(opts, 0);
int rc = cfg_parse(cfg, tmp_path);
if ( rc != 0 ){
video_mode = 2;
audio_level = 5;
fullscreen = 0;
high_score = 0;
}
if (video_mode == 0)
video_mode = 2;
god->scalar.scale = video_mode;
god->state.settings_volume = audio_level;
god->state.high_score = high_score;
god->scalar.fs = fullscreen;
FILE *fp = fopen(tmp_path, "w");
cfg_print(cfg, fp);
fclose(fp);
cfg_free(cfg);
}
int main(void)
{
/* ... setup options ... */
cfg = cfg_init(opts, CFGF_NONE);
cfg_parse(cfg, "hello.conf");
if(cfg_size(cfg, "greeting") == 0)
{
cfg_parse_buf(cfg, "greeting Hello {}");
}
/* ... print the greetings ... */
}
int main(int argc, char **argv) {
int retval;
signal(SIGINT, (void *)ctrlc);
if (argc < 2) {
usage(argv[0]);
return 0;
}
cfg = cfg_parse(argv[1]);
if (!cfg || !cfg_validate_all(cfg, ERROR_MODE)) {
return 0;
}
if (log_open()) {
lbanner();
}
if (!proxy_parse()) {
return 0;
}
retval = fork();
if (retval < 0) {
perror("fork");
return 0;
} else {
if (!retval) {
daemon_start();
fprintf(stderr, "*** An error occurred. Please check %s for more details! ***\n",
(char *) hashtable_lookup(cfg, "daemon-logfile"));
log_close();
_exit(1);
}
}
return 1;
}
void identify_image(char *label,char *options)
{
identify = label;
opt = options;
if (verbose>=2) printf("identify_image: id='%s' opt='%s'\n", label, options);
idefault = !!strchr(opt,'D');
if (idefault) identify = "";
cfg_init(cf_identify);
if (cfg_parse(cf_identify)) cfg_error("Syntax error");
if (idefault && first) {
printf("%s\n", dflt ? dflt : first);
exit(0);
}
die("No image found for \"%s\"",label);
}
int main(void)
{
char *comment;
char *expect = "Now, is it this comment that goes with the option?";
cfg_t *cfg;
cfg_opt_t *opt;
cfg_opt_t section_opts[] = {
CFG_INT("key", 0, CFGF_NONE),
CFG_BOOL("bool", 0, CFGF_NONE),
CFG_STR("option", NULL, CFGF_NONE),
CFG_END()
};
cfg_opt_t opts[] = {
CFG_STR("option", NULL, CFGF_NONE),
CFG_SEC("section", section_opts, CFGF_MULTI),
CFG_END()
};
cfg = cfg_init(opts, CFGF_COMMENTS);
fail_unless(cfg != NULL);
fail_unless(cfg_parse(cfg, SRC_DIR "/annotate.conf") == CFG_SUCCESS);
/* Verify the parser read the correct comment for this tricky option */
opt = cfg_getopt(cfg, "section|option");
fail_unless(opt != NULL);
comment = cfg_opt_getcomment(opt);
fail_unless(comment != NULL);
fail_unless(strcmp(comment, expect) == 0);
expect = "But what's the worst poetry in the universe?";
fail_unless(cfg_opt_setcomment(opt, expect) == CFG_SUCCESS);
cfg_opt_setnstr(opt, "Paula Nancy Millstone Jennings was a poet who wrote the worst poetry in "
"the universe. In fact, her poetry is still considered to be the worst in "
"the Galaxy, closely followed by that of the Azgoths of Kria and the "
"Vogons, in that order.", 0);
/* Verify that the comment is not reset when changing option value */
comment = cfg_opt_getcomment(opt);
fail_unless(comment != NULL);
fail_unless(strcmp(comment, expect) == 0);
cfg_print(cfg, stdout);
fail_unless(cfg_free(cfg) == CFG_SUCCESS);
return 0;
}
/* Public
*
* Read and parse the config
*/
struct cfg *cfg_read(const char* filename, enum cfg_status *status)
{
struct cfg *cfg=NULL;
struct cfg_string *str=NULL;
size_t current=0;
str = read_whole_file(filename);
if (!str) {
*status = CFG_READ_ERROR;
return NULL;
}
cfg=cfg_parse(str, ¤t, status);
str=cfg_string_free(str);
return cfg;
}
AM_ErrorCode_t AM_CFG_Input(const char *path,
AM_CFG_SecBeginCb_t sec_begin_cb,
AM_CFG_KeyCb_t key_cb,
AM_CFG_SecEndCb_t sec_end_cb,
void *user_data)
{
AM_CFG_Parser_t parser;
FILE *fp;
AM_ErrorCode_t ret;
assert(path);
if (!(fp = fopen(path, "r")))
{
AM_DEBUG(1, "%s", strerror(errno));
return AM_CFG_ERR_CANNOT_OPEN_FILE;
}
memset(&parser, 0, sizeof(AM_CFG_Parser_t));
parser.path = path;
parser.line = 1;
parser.fp = fp;
parser.sec_begin_cb = sec_begin_cb;
parser.sec_end_cb = sec_end_cb;
parser.key_cb = key_cb;
parser.user_data = user_data;
ret = cfg_parse(&parser);
if(parser.sec_stack)
{
AM_DEBUG(1, "\'}\' mismatch");
cfg_error(&parser);
}
while(parser.sec_stack)
{
cfg_pop_sec(&parser);
}
if(parser.buffer)
AM_MEM_Free(parser.buffer);
fclose(fp);
return ret;
}
/**
* Parses the config file
*
* @return a pointer to the configuration data structure, NULL on failure
*/
static cfg_t * parse_config(void) {
cfg_t * cfg = NULL;
cfg_opt_t target_opts[] = {
CFG_STR("comment", 0, CFGF_NONE),
CFG_INT("strip", 0, CFGF_NONE),
CFG_STR("rewrite_prefix", 0, CFGF_NONE),
CFG_FLOAT("prob", 0, CFGF_NONE),
CFG_INT("hash_index", 0, CFGF_NONE),
CFG_STR("rewrite_suffix", 0, CFGF_NONE),
CFG_INT("status", 1, CFGF_NONE),
CFG_INT_LIST("backed_up", NULL, CFGF_NONE),
CFG_INT("backup", -1, CFGF_NONE),
CFG_END()
};
cfg_opt_t prefix_opts[] = {
CFG_SEC("target", target_opts, CFGF_MULTI | CFGF_TITLE),
CFG_INT("max_targets", -1, CFGF_NONE),
CFG_END()
};
cfg_opt_t domain_opts[] = {
CFG_SEC("prefix", prefix_opts, CFGF_MULTI | CFGF_TITLE),
CFG_END()
};
cfg_opt_t opts[] = {
CFG_SEC("domain", domain_opts, CFGF_MULTI | CFGF_TITLE),
CFG_END()
};
cfg = cfg_init(opts, CFGF_NONE);
cfg_set_error_function(cfg, conf_error);
switch (cfg_parse(cfg, config_file)) {
case CFG_FILE_ERROR: LM_ERR("file not found: %s\n", config_file);
return NULL;
case CFG_PARSE_ERROR: LM_ERR("error while parsing %s in line %i, section %s\n",
cfg->filename, cfg->line, cfg->name);
return NULL;
case CFG_SUCCESS: break;
}
return cfg;
}
int main(void)
{
cfg_opt_t group_opts[] = {
CFG_INT("number", 0, CFGF_NONE),
CFG_INT("total", 0, CFGF_NONE),
CFG_END()
};
cfg_opt_t groups_opts[] = {
CFG_STR("name", "Esmé", CFGF_NONE),
CFG_SEC("group", group_opts, CFGF_TITLE | CFGF_MULTI),
CFG_END()
};
cfg_opt_t opts[] = {
CFG_SEC("groups", groups_opts, CFGF_NONE),
CFG_END()
};
cfg_t *cfg, *sec;
size_t i, j;
cfg = cfg_init(opts, CFGF_NONE);
if (!cfg || cfg_parse(cfg, CONF) == CFG_PARSE_ERROR) {
perror("Failed parsing " CONF);
return 1;
}
/* Iterate over the sections and print fields from each section. */
for (i = 0; i < cfg_size(cfg, "groups"); i++) {
sec = cfg_getnsec(cfg, "groups", i);
for (j = 0; j < cfg_size(sec, "group"); j++) {
cfg_t *opt = cfg_getnsec(sec, "group", j);
printf("group title: '%s'\n", cfg_title(opt));
printf("group number: %ld\n", cfg_getint(opt, "number"));
printf("group total: %ld\n", cfg_getint(opt, "total"));
printf("\n");
}
}
cfg_free(cfg);
return 0;
}
svm_model_info * get_svm_model_info(const char * filename){
cfg_opt_t * opts = get_opt();
cfg_t *cfg;
cfg = cfg_init(opts, CFGF_NONE);
cfg_parse(cfg, filename);
svm_model_info * info;
info = (svm_model_info*)malloc(sizeof(svm_model_info));
info->svm_type = cfg_getint(cfg,"svm_type");
info->kernel_type = cfg_getint(cfg,"kernel_type");
info->C = cfg_getfloat(cfg,"C");
info->gamma = cfg_getfloat(cfg,"gamma");
cfg_free(cfg);
return info;
}
/**
* 通过配置装载变量
* @param[in] args 配置参数
* @return 0 配置解析装载成功
* @return !0 配置解析装载失败
*/
int32_t gen_cfg_load_variable(gen_args_t* args)
{
FILE*file = fopen(args->cfg_file_path, "r");
if (!file)
{
LIB_ERROR(PARSER,"open config file '%s' fail,error=%s!\n", args->cfg_file_path,
strerror(errno));
return -1;
}
if (cfg_parse(args, file))
{
LIB_ERROR(PARSER,"parser config file '%s' fail!\n",args->cfg_file_path);
fclose(file);
return -1;
}
fclose(file);
return 0;
}
Ganglia_gmond_config
Ganglia_gmond_config_create(char *path, int fallback_to_default)
{
cfg_t *config = NULL;
/* Make sure we process ~ in the filename if the shell doesn't */
char *tilde_expanded = cfg_tilde_expand( path );
config = cfg_init( gmond_opts, CFGF_NOCASE );
switch( cfg_parse( config, tilde_expanded ) )
{
case CFG_FILE_ERROR:
/* Unable to open file so we'll go with the configuration defaults */
err_msg("Configuration file '%s' not found.\n", tilde_expanded);
if(!fallback_to_default)
{
/* Don't fallback to the default configuration.. just exit. */
exit(1);
}
/* .. otherwise use our default configuration */
if(cfg_parse_buf(config, default_gmond_configuration) == CFG_PARSE_ERROR)
{
err_msg("Your default configuration buffer failed to parse. Exiting.\n");
exit(1);
}
break;
case CFG_PARSE_ERROR:
err_msg("Parse error for '%s'\n", tilde_expanded );
exit(1);
case CFG_SUCCESS:
break;
default:
/* I have no clue whats goin' on here... */
exit(1);
}
if(tilde_expanded)
free(tilde_expanded);
#if 0
atexit(cleanup_configuration_file);
#endif
return (Ganglia_gmond_config)config;
}
