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;
}
/*
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;
}
bool readConfig(cfg_t **cfg) {
// All the const_cast keywords is to remove the compiler warnings generated by the C++-compiler.
cfg_opt_t controller_opts[] = {
CFG_INT(const_cast<char *>("id"), -1, CFGF_NONE),
CFG_STR(const_cast<char *>("name"), const_cast<char *>(""), CFGF_NONE),
CFG_INT(const_cast<char *>("type"), 0, CFGF_NONE),
CFG_STR(const_cast<char *>("serial"), const_cast<char *>(""), CFGF_NONE),
CFG_END()
};
cfg_opt_t device_parameter_opts[] = {
// Groups
CFG_STR(const_cast<char *>("devices"), 0, CFGF_NONE),
CFG_STR(const_cast<char *>("house"), 0, CFGF_NONE),
CFG_STR(const_cast<char *>("unit"), 0, CFGF_NONE),
CFG_STR(const_cast<char *>("code"), 0, CFGF_NONE),
CFG_STR(const_cast<char *>("system"), 0, CFGF_NONE),
CFG_STR(const_cast<char *>("units"), 0, CFGF_NONE),
CFG_STR(const_cast<char *>("fade"), 0, CFGF_NONE),
CFG_END()
};
cfg_opt_t device_opts[] = {
CFG_INT(const_cast<char *>("id"), -1, CFGF_NONE),
CFG_STR(const_cast<char *>("name"), const_cast<char *>("Unnamed"), CFGF_NONE),
CFG_INT(const_cast<char *>("controller"), 0, CFGF_NONE),
CFG_STR(const_cast<char *>("protocol"), const_cast<char *>("arctech"), CFGF_NONE),
CFG_STR(const_cast<char *>("model"), const_cast<char *>(""), CFGF_NONE),
CFG_SEC(const_cast<char *>("parameters"), device_parameter_opts, CFGF_NONE),
CFG_END()
};
cfg_opt_t opts[] = {
CFG_STR(const_cast<char *>("user"), const_cast<char *>("nobody"), CFGF_NONE),
CFG_STR(const_cast<char *>("group"), const_cast<char *>("plugdev"), CFGF_NONE),
CFG_STR(const_cast<char *>("deviceNode"), const_cast<char *>("/dev/tellstick"), CFGF_NONE),
CFG_STR(const_cast<char *>("ignoreControllerConfirmation"), const_cast<char *>("false"), CFGF_NONE),
CFG_SEC(const_cast<char *>("device"), device_opts, CFGF_MULTI),
CFG_SEC(const_cast<char *>("controller"), controller_opts, CFGF_MULTI),
CFG_END()
};
FILE *fp = fopen(CONFIG_FILE, "re"); // e for setting O_CLOEXEC on the file handle
if (!fp) {
return false;
}
(*cfg) = cfg_init(opts, CFGF_NOCASE);
if (cfg_parse_fp((*cfg), fp) == CFG_PARSE_ERROR) {
(*cfg) = 0;
fclose(fp);
return false;
}
fclose(fp);
return true;
}
void validate_setup(void)
{
cfg_opt_t *opt = 0;
static cfg_opt_t action_opts[] = {
CFG_INT("speed", 0, CFGF_NONE),
CFG_STR("name", 0, CFGF_NONE),
CFG_INT("xspeed", 0, CFGF_NONE),
CFG_END()
};
static cfg_opt_t multi_opts[] = {
CFG_INT_LIST("speeds", 0, CFGF_NONE),
CFG_SEC("options", action_opts, CFGF_NONE),
CFG_END()
};
cfg_opt_t opts[] = {
CFG_STR_LIST("ip-address", 0, CFGF_NONE),
CFG_INT_CB("action", ACTION_NONE, CFGF_NONE, parse_action),
CFG_SEC("options", action_opts, CFGF_NONE),
CFG_SEC("multi_options", multi_opts, CFGF_MULTI),
CFG_END()
};
cfg = cfg_init(opts, 0);
cfg_set_validate_func(cfg, "ip-address", validate_ip);
fail_unless(cfg_set_validate_func(cfg, "ip-address", validate_ip) == validate_ip);
opt = cfg_getopt(cfg, "ip-address");
fail_unless(opt != 0);
fail_unless(opt->validcb == validate_ip);
cfg_set_validate_func(cfg, "options", validate_action);
fail_unless(cfg_set_validate_func(cfg, "options", validate_action) == validate_action);
opt = cfg_getopt(cfg, "options");
fail_unless(opt != 0);
fail_unless(opt->validcb == validate_action);
cfg_set_validate_func(cfg, "options|speed", validate_speed);
fail_unless(cfg_set_validate_func(cfg, "options|speed", validate_speed) == validate_speed);
opt = cfg_getopt(cfg, "options|speed");
fail_unless(opt != 0);
fail_unless(opt->validcb == validate_speed);
cfg_set_validate_func(cfg, "multi_options|speeds", validate_speed);
fail_unless(cfg_set_validate_func(cfg, "multi_options|speeds", validate_speed) == validate_speed);
cfg_set_validate_func(cfg, "multi_options|options|xspeed", validate_speed);
fail_unless(cfg_set_validate_func(cfg, "multi_options|options|xspeed", validate_speed) == validate_speed);
/* Validate callbacks for *set*() functions, i.e. not when parsing file content */
cfg_set_validate_func2(cfg, "multi_options|speed", validate_speed2);
cfg_set_validate_func2(cfg, "multi_options|options|name", validate_name2);
}
static cfg_t *create_config(void)
{
static cfg_opt_t sec_opts[] = {
CFG_INT("a", 1, CFGF_NONE),
CFG_INT("b", 2, CFGF_NONE),
CFG_END()
};
cfg_opt_t opts[] = {
CFG_SEC("sec", sec_opts, CFGF_MULTI | CFGF_TITLE),
CFG_END()
};
return cfg_init(opts, 0);
}
cfg_opt_t * build_section(section_t *section, section_ptrs &ptrs)
{
static const char *funcname = "conf::build_section";
cfg_opt_t *ptr = new cfg_opt_t[section->size() + 1];
ptrs.push_back(std::unique_ptr<cfg_opt_t []>(ptr));
for (auto &entry : *section)
{
char *name = const_cast<char *>(entry.first.c_str());
switch (entry.second.what_type())
{
case val_type::integer: *ptr = CFG_INT(name, 0, CFGF_NODEFAULT); break;
case val_type::string: *ptr = CFG_STR(name, 0, CFGF_NODEFAULT); break;
case val_type::multistring: *ptr = CFG_STR_LIST(name, 0, CFGF_NODEFAULT); break;
case val_type::section: *ptr = CFG_SEC(name, build_section(entry.second.get<conf::section_t *>(), ptrs), CFGF_NONE); break;
case val_type::unknown:
throw logging::error(funcname, "Val with unknown type in section: %s", name);
}
ptr++;
}
*ptr = CFG_END();
return ptrs.back().get();
}
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);
}
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;
}
BOOL saveConfFile(user_input_data *user_dat)
{
FILE *U2Mconf_file = fopen(cfg_filename, "w");
if (!U2Mconf_file) return FALSE;
cfg_opt_t email_opts[] = {
CFG_STR("From", user_dat->FROM, CFGF_NONE),
CFG_STR("To", user_dat->TO, CFGF_NONE),
CFG_STR("Cc", user_dat->CC, CFGF_NONE),
CFG_STR("Subject", user_dat->SUBJECT, CFGF_NONE),
CFG_STR("Body", user_dat->BODY, CFGF_NONE),
CFG_STR("Password", user_dat->pass, CFGF_NONE),
CFG_STR("SMTP_server", user_dat->SMTP_SERVER, CFGF_NONE),
CFG_INT("Port_number", (int)user_dat->PORT, CFGF_NONE),
CFG_END()
};
cfg_t *U2MConf = cfg_init(email_opts, CFGF_NONE);
cfg_print(U2MConf, U2Mconf_file);
fclose(U2Mconf_file);
cfg_free(U2MConf);
return TRUE;
}
bool readVarConfig(cfg_t **cfg) {
cfg_opt_t device_opts[] = {
CFG_INT(const_cast<char *>("state"), 0, CFGF_NONE),
CFG_STR(const_cast<char *>("stateValue"), const_cast<char *>(""), CFGF_NONE),
CFG_END()
};
cfg_opt_t opts[] = {
CFG_SEC(const_cast<char *>("device"), device_opts, CFGF_MULTI | CFGF_TITLE),
CFG_END()
};
FILE *fp = fopen(VAR_CONFIG_FILE, "re"); // e for setting O_CLOEXEC on the file handle
if (!fp) {
Log::warning("Unable to open var config file, %s", VAR_CONFIG_FILE);
return false;
}
(*cfg) = cfg_init(opts, CFGF_NOCASE);
if (cfg_parse_fp((*cfg), fp) == CFG_PARSE_ERROR) {
(*cfg) = 0;
fclose(fp);
Log::warning("Unable to parse var config file, %s", VAR_CONFIG_FILE);
return false;
}
fclose(fp);
return true;
}
int main(void)
{
cfg_opt_t sub_opts[] = {
CFG_BOOL("bool", cfg_false, CFGF_NONE),
CFG_STR("string", NULL, CFGF_NONE),
CFG_INT("int", 0, CFGF_NONE),
CFG_FLOAT("float", 0.0, CFGF_NONE),
CFG_END()
};
cfg_opt_t opts[] = {
CFG_BOOL_LIST("bool", cfg_false, CFGF_NONE),
CFG_STR_LIST("string", NULL, CFGF_NONE),
CFG_INT_LIST("int", 0, CFGF_NONE),
CFG_FLOAT_LIST("float", "0.0", CFGF_NONE),
CFG_SEC("sub", sub_opts,
CFGF_MULTI | CFGF_TITLE | CFGF_NO_TITLE_DUPES),
CFG_END()
};
char *cmd = NULL;
const char *reply;
int res;
int i;
cfg = cfg_init(opts, CFGF_NONE);
for (;;) {
printf("cli> ");
fflush(stdout);
if (cmd)
free(cmd);
cmd = input_cmd();
if (!cmd)
exit(0);
res = split_cmd(cmd);
if (res < 0) {
printf("Parse error\n");
continue;
}
if (cmdc == 0)
continue;
for (i = 0; cmds[i].cmd; ++i) {
if (strcmp(cmdv[0], cmds[i].cmd))
continue;
reply = cmds[i].handler(cmdc, cmdv);
if (!reply)
exit(0);
printf("%s", reply);
break;
}
if (!cmds[i].cmd)
printf("Unknown command\n");
}
cfg_free(cfg);
return 0;
}
/**
* 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;
}
cfg_opt_t * get_opt(){
static cfg_opt_t opts[] = {
CFG_STR("user", "root", CFGF_NONE),
CFG_STR("password", "", CFGF_NONE),
CFG_STR("dbname", "", CFGF_NONE),
CFG_STR("ip", "127.0.0.1", CFGF_NONE),
CFG_INT("port", 5432, CFGF_NONE),
CFG_STR("db_query", "", CFGF_NONE),
CFG_INT("svm_type",0, CFGF_NONE),
CFG_INT("kernel_type",0,CFGF_NONE),
CFG_FLOAT("gamma",0,CFGF_NONE),
CFG_FLOAT("C",1,CFGF_NONE),
CFG_STR("model_filename", "file.model", CFGF_NONE),
CFG_STR("model_list_path","",CFGF_NONE),
CFG_STR_LIST("model_list","{}",CFGF_NONE),
CFG_STR_LIST("query_list","{}",CFGF_NONE),
CFG_STR_LIST("model_label_list","{}",CFGF_NONE),
CFG_END()
};
return opts;
}
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;
}
cfg_t *parse_conf(const char *filename)
{
cfg_opt_t bookmark_opts[] = {
CFG_STR("host", 0, CFGF_NODEFAULT),
CFG_INT("port", 21, CFGF_NONE),
CFG_STR("login", "anonymous", CFGF_NONE),
CFG_STR("password", "anonymous@", CFGF_NONE),
CFG_STR("directory", 0, CFGF_NONE),
CFG_END()
};
cfg_opt_t opts[] = {
CFG_SEC("bookmark", bookmark_opts, CFGF_MULTI | CFGF_TITLE),
CFG_BOOL("reverse-dns", cfg_true, CFGF_NONE),
CFG_BOOL("passive-mode", cfg_false, CFGF_NONE),
CFG_BOOL("remote-completion", cfg_true, CFGF_NONE),
CFG_FUNC("alias", conf_alias),
CFG_STR_LIST("xterm-terminals", "{xterm, rxvt}", CFGF_NONE),
CFG_INT_CB("auto-create-bookmark", ACB_YES, CFGF_NONE, conf_parse_acb),
CFG_FUNC("include-file", cfg_include),
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;
}
int main(void)
{
cfg_opt_t greet_opts[] =
{
CFG_STR_LIST("targets", "{World}", CFGF_NONE),
CFG_INT("repeat", 1, CFGF_NONE),
CFG_END()
};
cfg_opt_t opts[] =
{
CFG_SEC("greeting", greet_opts, CFGF_TITLE | CFGF_MULTI),
CFG_END()
};
cfg_t *cfg, *cfg_greet;
int repeat;
int i, j;
cfg = cfg_init(opts, CFGF_NONE);
cfg_set_validate_func(cfg, "greeting|repeat", validate_unsigned_int);
if(cfg_parse(cfg, "hello.conf") == CFG_PARSE_ERROR)
return 1;
for(j = 0; j < cfg_size(cfg, "greeting"); j++)
{
cfg_greet = cfg_getnsec(cfg, "greeting", j);
repeat = cfg_getint(cfg_greet, "repeat");
while(repeat--)
{
printf("%s", cfg_title(cfg_greet));
for(i = 0; i < cfg_size(cfg_greet, "targets"); i++)
printf(", %s", cfg_getnstr(cfg_greet, "targets", i));
printf("!\n");
}
}
cfg_free(cfg);
return 0;
}
*
* This function comes from libconfuse and is not called
* in cfg_free(), that's why call it here.
* \note Require libconfuse >= 2.6.
* \return 0
*/
extern int cfg_yylex_destroy(void);
/**
* \var denied_address_opts
* \brief Denied address option.
*/
static cfg_opt_t denied_address_opts[] =
{
CFG_STR("address", "", CFGF_NONE),
CFG_INT("mask", 24, CFGF_NONE),
CFG_INT("port", 0, CFGF_NONE),
CFG_END()
};
/**
* \var opts
* \brief Options recognized.
*/
static cfg_opt_t opts[]=
{
CFG_STR("listen_address", NULL, CFGF_LIST),
CFG_STR("listen_addressv6", NULL, CFGF_LIST),
CFG_INT("udp_port", 3478, CFGF_NONE),
CFG_INT("tcp_port", 3478, CFGF_NONE),
CFG_INT("tls_port", 5349, CFGF_NONE),
CFG_STR("gototab_6_key", "<Alt>6", CFGF_NONE),
CFG_STR("gototab_7_key", "<Alt>7", CFGF_NONE),
CFG_STR("gototab_8_key", "<Alt>8", CFGF_NONE),
CFG_STR("gototab_9_key", "<Alt>9", CFGF_NONE),
CFG_STR("gototab_10_key", "<Alt>0", CFGF_NONE),
CFG_STR("copy_key", "<Shift><Control>c", CFGF_NONE),
CFG_STR("paste_key", "<Shift><Control>v", CFGF_NONE),
CFG_STR("quit_key", "<Shift><Control>q", CFGF_NONE),
CFG_STR("title", "Tilda", CFGF_NONE),
CFG_STR("background_color", "white", CFGF_NONE),
CFG_STR("working_dir", NULL, CFGF_NONE),
CFG_STR("web_browser", "x-www-browser", CFGF_NONE),
CFG_STR("word_chars", DEFAULT_WORD_CHARS, CFGF_NONE),
/* ints */
CFG_INT("lines", 100, CFGF_NONE),
CFG_INT("max_width", 600, CFGF_NONE),
CFG_INT("max_height", 150, CFGF_NONE),
CFG_INT("min_width", 1, CFGF_NONE),
CFG_INT("min_height", 1, CFGF_NONE),
CFG_INT("transparency", 0, CFGF_NONE),
CFG_INT("x_pos", 0, CFGF_NONE),
CFG_INT("y_pos", 0, CFGF_NONE),
CFG_INT("tab_pos", 0, CFGF_NONE),
CFG_INT("backspace_key", 0, CFGF_NONE),
CFG_INT("delete_key", 1, CFGF_NONE),
CFG_INT("d_set_title", 3, CFGF_NONE),
CFG_INT("command_exit", 2, CFGF_NONE),
CFG_INT("scheme", 3, CFGF_NONE),
CFG_INT("slide_sleep_usec", 20000, CFGF_NONE),
CFG_INT("animation_orientation", 0, CFGF_NONE),
int main(int argc, char **argv)
{
//Check if user == root
if(geteuid() != 0)
{
puts("Please run this software as root!");
exit(EXIT_FAILURE);
}
// check for non-daemon mode for debugging
for(int i = 1; i < argc; i++) {
if (str_is(argv[i], "nodaemon")) {
start_daemon = 0;
break;
}
}
if (start_daemon) {
//Init daemon, can be replaced with daemon() call
pid_t pid;
pid = fork();
if (pid < 0)
{
exit(EXIT_FAILURE);
}
if (pid > 0)
{
exit(EXIT_SUCCESS);
}
umask(0);
//We are now running as the forked child process.
openlog(argv[0],LOG_NOWAIT|LOG_PID,LOG_USER);
pid_t sid;
sid = setsid();
if (sid < 0)
{
syslog(LOG_ERR, "Could not create process group\n");
exit(EXIT_FAILURE);
}
if ((chdir("/")) < 0)
{
syslog(LOG_ERR, "Could not change working directory to /\n");
exit(EXIT_FAILURE);
}
}
else {
// open syslog for non-daemon mode
openlog(argv[0],LOG_NOWAIT|LOG_PID,LOG_USER);
}
//Read configuration file
cfg_opt_t opts[] =
{
CFG_INT("i2cbus", 1, CFGF_NONE),
CFG_INT("frequency", 99800, CFGF_NONE),
CFG_BOOL("stereo", 1, CFGF_NONE),
CFG_BOOL("rdsenable", 1, CFGF_NONE),
CFG_BOOL("poweron", 1, CFGF_NONE),
CFG_BOOL("tcpbindlocal", 1, CFGF_NONE),
CFG_INT("tcpport", 42516, CFGF_NONE),
CFG_INT("txpower", 3, CFGF_NONE),
CFG_BOOL("gain", 0, CFGF_NONE),
CFG_INT("volume", 3, CFGF_NONE),
CFG_INT("rdspin", 17, CFGF_NONE),
CFG_STR("rdsid", "", CFGF_NONE),
CFG_STR("rdstext", "", CFGF_NONE),
CFG_INT("ledpin", 27, CFGF_NONE),
CFG_END()
};
cfg = cfg_init(opts, CFGF_NONE);
if (cfg_parse(cfg, "/etc/fmberry.conf") == CFG_PARSE_ERROR)
return 1;
// get LED pin number
int led = 1; // led state
ledpin = cfg_getint(cfg, "ledpin");
rdsint = cfg_getint(cfg, "rdspin");
// Init I2C bus and transmitter with initial frequency and state
if (ns741_init(cfg_getint(cfg, "i2cbus"), cfg_getint(cfg, "frequency")) == -1)
{
syslog(LOG_ERR, "Init failed! Double-check hardware and try again!\n");
exit(EXIT_FAILURE);
}
syslog(LOG_NOTICE, "Successfully initialized ns741 transmitter.\n");
int nfds;
struct pollfd polls[2];
// open TCP listener socket, will exit() in case of error
int lst = ListenTCP(cfg_getint(cfg, "tcpport"));
polls[0].fd = lst;
polls[0].events = POLLIN;
nfds = 1;
// initialize data structure for 'status' command
bzero(&mmr70, sizeof(mmr70));
mmr70.frequency = cfg_getint(cfg, "frequency");
mmr70.power = cfg_getbool(cfg, "poweron");
mmr70.txpower = cfg_getint(cfg, "txpower");
mmr70.mute = 0;
mmr70.gain = cfg_getbool(cfg, "gain");
mmr70.volume = cfg_getint(cfg, "volume");
mmr70.stereo = cfg_getbool(cfg, "stereo");
mmr70.rds = cfg_getbool(cfg, "rdsenable");
strncpy(mmr70.rdsid, cfg_getstr(cfg, "rdsid"), 8);
strncpy(mmr70.rdstext, cfg_getstr(cfg, "rdstext"), 64);
// apply configuration parameters
ns741_txpwr(mmr70.txpower);
ns741_mute(mmr70.mute);
ns741_stereo(mmr70.stereo);
ns741_rds_set_progname(mmr70.rdsid);
ns741_rds_set_radiotext(mmr70.rdstext);
ns741_power(mmr70.power);
ns741_input_gain(mmr70.gain);
ns741_volume(mmr70.volume);
// Use RPI_REV1 for earlier versions of Raspberry Pi
rpi_pin_init(RPI_REVISION);
// Get file descriptor for RDS handler
polls[1].revents = 0;
if (mmr70.rds)
{
int rds = rpi_pin_poll_enable(rdsint, EDGE_FALLING);
if (rds < 0) {
printf("Couldn't enable RDS support\n");
run = 0;
}
polls[1].fd = rds;
polls[1].events = POLLPRI;
nfds = 2;
if (ledpin > 0) {
rpi_pin_export(ledpin, RPI_OUTPUT);
rpi_pin_set(ledpin, led);
}
ns741_rds(1);
ns741_rds_isr(); // send first two bytes
}
// main polling loop
int ledcounter = 0;
while(run) {
if (poll(polls, nfds, -1) < 0)
break;
if (polls[1].revents) {
rpi_pin_poll_clear(polls[1].fd);
ns741_rds_isr();
// flash LED if enabled on every other RDS refresh cycle
if (ledpin > 0) {
ledcounter++;
if (!(ledcounter % 80)) {
led ^= 1;
rpi_pin_set(ledpin, led);
}
}
}
if (polls[0].revents)
ProcessTCP(lst, &mmr70);
}
// clean up at exit
ns741_power(0);
if (mmr70.rds)
rpi_pin_unexport(rdsint);
if (ledpin > 0) {
rpi_pin_set(ledpin, 0);
rpi_pin_unexport(ledpin);
}
close(lst);
closelog();
return 0;
}
/**
* @brief 根据 conf 文件加载业务名称与gameid的对应关系;
* @load_count 本次被加载的条数;
* @return -1: failed, 0: succ
*/
int load_svc_gameid_map(const char *conf_path, uint32_t *load_count)
{
uint32_t n, last;
int i, ret;
cfg_t *si;
struct svc_gameid_map_t *sg;
static cfg_opt_t svcinfo_opts[] = {
CFG_STR("name", 0, CFGF_NONE),
CFG_INT("gameid", 0, CFGF_NONE),
CFG_END()
};
cfg_opt_t opts[] = {
CFG_SEC("svcinfo", svcinfo_opts, CFGF_MULTI | CFGF_TITLE),
CFG_END()
};
cfg_t *cfg = cfg_init(opts, CFGF_NONE);
/* set a validating callback function for svcinfo sections */
cfg_set_validate_func(cfg, "svcinfo", &cb_validate_svcinfo);
ret = cfg_parse(cfg, conf_path ? conf_path : DEF_SVC_CFG_PATH);
if(ret == CFG_FILE_ERROR) {
fprintf(stderr, "Access error, conf: %s, err: %s\n",
conf_path ? conf_path : DEF_SVC_CFG_PATH, strerror(errno));
return -1;
} else if(ret == CFG_PARSE_ERROR) {
fprintf(stderr, "Parse error, conf: %s\n",
conf_path ? conf_path : DEF_SVC_CFG_PATH);
return -1;
}
memset(sg_map_shadow, 0, sizeof(sg_map_shadow));
n = cfg_size(cfg, "svcinfo");
for(i = 0; i < n; i++) {
if (i == MAX_SVC_NUM) break;
si = cfg_getnsec(cfg, "svcinfo", i);
sg = &(sg_map_shadow[i]);
snprintf(sg->name, sizeof(sg->name), "%s", cfg_getstr(si, "name"));
sg->gameid = cfg_getint(si, "gameid");
cur_svcinfo_count_shadow++;
}
cfg_free(cfg);
/* sort sg */
qsort(sg_map_shadow, cur_svcinfo_count_shadow, sizeof(sg_map_shadow[0]), svcinfocmp);
last = 0;
for (i = 0; i < cur_svcinfo_count_shadow; i++) {
sg = &(sg_map_shadow[i]);
if (sg->gameid == last) {
fprintf(stderr, "dup gameid: %u in conf: %s\n", last,
conf_path ? conf_path : DEF_SVC_CFG_PATH);
return -1;
}
if (sg->gameid > MAX_SVC_NUM) {
fprintf(stderr, "gameid: %u > max(%u) in conf: %s\n",
sg->gameid, MAX_SVC_NUM,
conf_path ? conf_path : DEF_SVC_CFG_PATH);
return -1;
}
last = sg->gameid;
}
svcinfo_enable = 0;
memcpy(sg_map, sg_map_shadow, sizeof(sg_map));
cur_svcinfo_count = cur_svcinfo_count_shadow;
if (load_count) {
*load_count = cur_svcinfo_count;
}
svcinfo_enable = 1;
return 0;
}
#include "e_lib.h"
#include "e_string.h"
// 03/27/05: EDF strings!
// String section keywords
#define ITEM_STRING_NUM "num"
#define ITEM_STRING_VAL "val"
#define ITEM_STRING_BEXDST "bexdest"
#define ITEM_STRING_BEXSRC "bexsource"
// String Options
cfg_opt_t edf_string_opts[] =
{
CFG_STR(ITEM_STRING_VAL, "", CFGF_NONE),
CFG_INT(ITEM_STRING_NUM, -1, CFGF_NONE),
CFG_STR(ITEM_STRING_BEXDST, "", CFGF_NONE),
CFG_STR(ITEM_STRING_BEXSRC, "", CFGF_NONE),
CFG_END()
};
#define NUM_EDFSTR_CHAINS 257
static edf_string_t *edf_str_chains[NUM_EDFSTR_CHAINS];
static DLListItem<edf_string_t> *edf_str_numchains[NUM_EDFSTR_CHAINS];
//
// haleyjd 08/05/05: To support editing the numeric keys of existing
// string objects, the numeric hash has to become a double-linked list.
// See the code in m_dllist.h to see how a generic double-linked list
// with **prev pointer is implemented.
CFG_STR("latlong", "unspecified", CFGF_NONE ),
CFG_STR("url", "unspecified", CFGF_NONE ),
CFG_END()
};
static cfg_opt_t host_opts[] = {
CFG_STR("location", "unspecified", CFGF_NONE ),
CFG_END()
};
static cfg_opt_t globals_opts[] = {
CFG_BOOL("daemonize", 1, CFGF_NONE),
CFG_BOOL("setuid", 1 - NO_SETUID, CFGF_NONE),
CFG_STR("user", SETUID_USER, CFGF_NONE),
/* later i guess we should add "group" as well */
CFG_INT("debug_level", 0, CFGF_NONE),
CFG_INT("max_udp_msg_len", 1472, CFGF_NONE),
CFG_BOOL("mute", 0, CFGF_NONE),
CFG_BOOL("deaf", 0, CFGF_NONE),
CFG_BOOL("allow_extra_data", 1, CFGF_NONE),
CFG_INT("host_dmax", 86400, CFGF_NONE),
CFG_INT("host_tmax", 20, CFGF_NONE),
CFG_INT("cleanup_threshold", 300, CFGF_NONE),
CFG_BOOL("gexec", 0, CFGF_NONE),
CFG_INT("send_metadata_interval", 0, CFGF_NONE),
CFG_STR("module_dir", NULL, CFGF_NONE),
CFG_STR("override_hostname", NULL, CFGF_NONE),
CFG_STR("override_ip", NULL, CFGF_NONE),
CFG_STR("tags", NULL, CFGF_NONE),
CFG_END()
};
} __attribute__ ((__packed__)) script_ent_t;
typedef struct dat_hdr {
int version[3];
char notes[512];
int num_families;
int num_devices;
int num_scripts;
uint8_t compat;
uint8_t unused1a;
uint16_t unused1b;
uint32_t unused2;
} dat_hdr_t;
cfg_opt_t config_opts[] = {
CFG_INT("ver_major", 0, CFGF_NONE),
CFG_INT("ver_minor", 0, CFGF_NONE),
CFG_INT("ver_dot", 0, CFGF_NONE),
CFG_INT("compat", 0, CFGF_NONE),
CFG_INT("unused1a", 0, CFGF_NONE),
CFG_INT("unused1b", 0, CFGF_NONE),
CFG_INT("unused2", 0, CFGF_NONE),
CFG_STR("notes", "", CFGF_NONE),
CFG_STR_LIST("families", "", CFGF_NONE),
CFG_STR_LIST("devices", "", CFGF_NONE),
CFG_STR_LIST("scripts", "", CFGF_NONE),
CFG_END()
};
cfg_opt_t script_opts[] = {
CFG_STR("org_name", "", CFGF_NONE),
int main(int argc, char *argv[])
{
/*
configuration options
*/
cfg_opt_t opts[] =
{
CFG_INT("vendor_id", 0, 0),
CFG_INT("product_id", 0, 0),
CFG_BOOL("self_powered", cfg_true, 0),
CFG_BOOL("remote_wakeup", cfg_true, 0),
CFG_BOOL("in_is_isochronous", cfg_false, 0),
CFG_BOOL("out_is_isochronous", cfg_false, 0),
CFG_BOOL("suspend_pull_downs", cfg_false, 0),
CFG_BOOL("use_serial", cfg_false, 0),
CFG_BOOL("change_usb_version", cfg_false, 0),
CFG_INT("usb_version", 0, 0),
CFG_INT("default_pid", 0x6001, 0),
CFG_INT("max_power", 0, 0),
CFG_STR("manufacturer", "Acme Inc.", 0),
CFG_STR("product", "USB Serial Converter", 0),
CFG_STR("serial", "08-15", 0),
CFG_INT("eeprom_type", 0x00, 0),
CFG_STR("filename", "", 0),
CFG_BOOL("flash_raw", cfg_false, 0),
CFG_BOOL("high_current", cfg_false, 0),
CFG_STR_LIST("cbus0", "{TXDEN,PWREN,RXLED,TXLED,TXRXLED,SLEEP,CLK48,CLK24,CLK12,CLK6,IO_MODE,BITBANG_WR,BITBANG_RD,SPECIAL}", 0),
CFG_STR_LIST("cbus1", "{TXDEN,PWREN,RXLED,TXLED,TXRXLED,SLEEP,CLK48,CLK24,CLK12,CLK6,IO_MODE,BITBANG_WR,BITBANG_RD,SPECIAL}", 0),
CFG_STR_LIST("cbus2", "{TXDEN,PWREN,RXLED,TXLED,TXRXLED,SLEEP,CLK48,CLK24,CLK12,CLK6,IO_MODE,BITBANG_WR,BITBANG_RD,SPECIAL}", 0),
CFG_STR_LIST("cbus3", "{TXDEN,PWREN,RXLED,TXLED,TXRXLED,SLEEP,CLK48,CLK24,CLK12,CLK6,IO_MODE,BITBANG_WR,BITBANG_RD,SPECIAL}", 0),
CFG_STR_LIST("cbus4", "{TXDEN,PWRON,RXLED,TXLED,TX_RX_LED,SLEEP,CLK48,CLK24,CLK12,CLK6}", 0),
CFG_BOOL("invert_txd", cfg_false, 0),
CFG_BOOL("invert_rxd", cfg_false, 0),
CFG_BOOL("invert_rts", cfg_false, 0),
CFG_BOOL("invert_cts", cfg_false, 0),
CFG_BOOL("invert_dtr", cfg_false, 0),
CFG_BOOL("invert_dsr", cfg_false, 0),
CFG_BOOL("invert_dcd", cfg_false, 0),
CFG_BOOL("invert_ri", cfg_false, 0),
CFG_END()
};
cfg_t *cfg;
/*
normal variables
*/
int _read = 0, _erase = 0, _flash = 0;
const int max_eeprom_size = 256;
int my_eeprom_size = 0;
unsigned char *eeprom_buf = NULL;
char *filename;
int size_check;
int i, argc_filename;
FILE *fp;
struct ftdi_context *ftdi = NULL;
printf("\nFTDI eeprom generator v%s\n", EEPROM_VERSION_STRING);
printf ("(c) Intra2net AG and the libftdi developers <*****@*****.**>\n");
if (argc != 2 && argc != 3)
{
printf("Syntax: %s [commands] config-file\n", argv[0]);
printf("Valid commands:\n");
printf("--read-eeprom Read eeprom and write to -filename- from config-file\n");
printf("--erase-eeprom Erase eeprom\n");
printf("--flash-eeprom Flash eeprom\n");
exit (-1);
}
if (argc == 3)
{
if (strcmp(argv[1], "--read-eeprom") == 0)
_read = 1;
else if (strcmp(argv[1], "--erase-eeprom") == 0)
_erase = 1;
else if (strcmp(argv[1], "--flash-eeprom") == 0)
_flash = 1;
else
{
printf ("Can't open configuration file\n");
exit (-1);
}
argc_filename = 2;
}
else
{
argc_filename = 1;
}
if ((fp = fopen(argv[argc_filename], "r")) == NULL)
{
printf ("Can't open configuration file\n");
exit (-1);
}
fclose (fp);
cfg = cfg_init(opts, 0);
cfg_parse(cfg, argv[argc_filename]);
filename = cfg_getstr(cfg, "filename");
if (cfg_getbool(cfg, "self_powered") && cfg_getint(cfg, "max_power") > 0)
printf("Hint: Self powered devices should have a max_power setting of 0.\n");
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "Failed to allocate ftdi structure :%s \n",
ftdi_get_error_string(ftdi));
return EXIT_FAILURE;
}
if (_read > 0 || _erase > 0 || _flash > 0)
{
int vendor_id = cfg_getint(cfg, "vendor_id");
int product_id = cfg_getint(cfg, "product_id");
i = ftdi_usb_open(ftdi, vendor_id, product_id);
if (i != 0)
{
int default_pid = cfg_getint(cfg, "default_pid");
printf("Unable to find FTDI devices under given vendor/product id: 0x%X/0x%X\n", vendor_id, product_id);
printf("Error code: %d (%s)\n", i, ftdi_get_error_string(ftdi));
printf("Retrying with default FTDI pid=%#04x.\n", default_pid);
i = ftdi_usb_open(ftdi, 0x0403, default_pid);
if (i != 0)
{
printf("Error: %s\n", ftdi->error_str);
exit (-1);
}
}
}
ftdi_eeprom_initdefaults (ftdi, cfg_getstr(cfg, "manufacturer"),
cfg_getstr(cfg, "product"),
cfg_getstr(cfg, "serial"));
printf("FTDI read eeprom: %d\n", ftdi_read_eeprom(ftdi));
eeprom_get_value(ftdi, CHIP_SIZE, &my_eeprom_size);
printf("EEPROM size: %d\n", my_eeprom_size);
if (_read > 0)
{
ftdi_eeprom_decode(ftdi, 1);
eeprom_buf = malloc(my_eeprom_size);
ftdi_get_eeprom_buf(ftdi, eeprom_buf, my_eeprom_size);
if (eeprom_buf == NULL)
{
fprintf(stderr, "Malloc failed, aborting\n");
goto cleanup;
}
if (filename != NULL && strlen(filename) > 0)
{
FILE *fp = fopen (filename, "wb");
fwrite (eeprom_buf, 1, my_eeprom_size, fp);
fclose (fp);
}
else
{
printf("Warning: Not writing eeprom, you must supply a valid filename\n");
}
goto cleanup;
}
eeprom_set_value(ftdi, VENDOR_ID, cfg_getint(cfg, "vendor_id"));
eeprom_set_value(ftdi, PRODUCT_ID, cfg_getint(cfg, "product_id"));
eeprom_set_value(ftdi, SELF_POWERED, cfg_getbool(cfg, "self_powered"));
eeprom_set_value(ftdi, REMOTE_WAKEUP, cfg_getbool(cfg, "remote_wakeup"));
eeprom_set_value(ftdi, MAX_POWER, cfg_getint(cfg, "max_power"));
eeprom_set_value(ftdi, IN_IS_ISOCHRONOUS, cfg_getbool(cfg, "in_is_isochronous"));
eeprom_set_value(ftdi, OUT_IS_ISOCHRONOUS, cfg_getbool(cfg, "out_is_isochronous"));
eeprom_set_value(ftdi, SUSPEND_PULL_DOWNS, cfg_getbool(cfg, "suspend_pull_downs"));
eeprom_set_value(ftdi, USE_SERIAL, cfg_getbool(cfg, "use_serial"));
eeprom_set_value(ftdi, USE_USB_VERSION, cfg_getbool(cfg, "change_usb_version"));
eeprom_set_value(ftdi, USB_VERSION, cfg_getint(cfg, "usb_version"));
eeprom_set_value(ftdi, CHIP_TYPE, cfg_getint(cfg, "eeprom_type"));
eeprom_set_value(ftdi, HIGH_CURRENT, cfg_getbool(cfg, "high_current"));
eeprom_set_value(ftdi, CBUS_FUNCTION_0, str_to_cbus(cfg_getstr(cfg, "cbus0"), 13));
eeprom_set_value(ftdi, CBUS_FUNCTION_1, str_to_cbus(cfg_getstr(cfg, "cbus1"), 13));
eeprom_set_value(ftdi, CBUS_FUNCTION_2, str_to_cbus(cfg_getstr(cfg, "cbus2"), 13));
eeprom_set_value(ftdi, CBUS_FUNCTION_3, str_to_cbus(cfg_getstr(cfg, "cbus3"), 13));
eeprom_set_value(ftdi, CBUS_FUNCTION_4, str_to_cbus(cfg_getstr(cfg, "cbus4"), 9));
int invert = 0;
if (cfg_getbool(cfg, "invert_rxd")) invert |= INVERT_RXD;
if (cfg_getbool(cfg, "invert_txd")) invert |= INVERT_TXD;
if (cfg_getbool(cfg, "invert_rts")) invert |= INVERT_RTS;
if (cfg_getbool(cfg, "invert_cts")) invert |= INVERT_CTS;
if (cfg_getbool(cfg, "invert_dtr")) invert |= INVERT_DTR;
if (cfg_getbool(cfg, "invert_dsr")) invert |= INVERT_DSR;
if (cfg_getbool(cfg, "invert_dcd")) invert |= INVERT_DCD;
if (cfg_getbool(cfg, "invert_ri")) invert |= INVERT_RI;
eeprom_set_value(ftdi, INVERT, invert);
eeprom_set_value(ftdi, CHANNEL_A_DRIVER, DRIVER_VCP);
eeprom_set_value(ftdi, CHANNEL_B_DRIVER, DRIVER_VCP);
eeprom_set_value(ftdi, CHANNEL_C_DRIVER, DRIVER_VCP);
eeprom_set_value(ftdi, CHANNEL_D_DRIVER, DRIVER_VCP);
eeprom_set_value(ftdi, CHANNEL_A_RS485, 0);
eeprom_set_value(ftdi, CHANNEL_B_RS485, 0);
eeprom_set_value(ftdi, CHANNEL_C_RS485, 0);
eeprom_set_value(ftdi, CHANNEL_D_RS485, 0);
if (_erase > 0)
{
printf("FTDI erase eeprom: %d\n", ftdi_erase_eeprom(ftdi));
}
size_check = ftdi_eeprom_build(ftdi);
eeprom_get_value(ftdi, CHIP_SIZE, &my_eeprom_size);
if (size_check == -1)
{
printf ("Sorry, the eeprom can only contain 128 bytes (100 bytes for your strings).\n");
printf ("You need to short your string by: %d bytes\n", size_check);
goto cleanup;
} else if (size_check < 0) {
printf ("ftdi_eeprom_build(): error: %d\n", size_check);
}
else
{
printf ("Used eeprom space: %d bytes\n", my_eeprom_size-size_check);
}
if (_flash > 0)
{
if (cfg_getbool(cfg, "flash_raw"))
{
if (filename != NULL && strlen(filename) > 0)
{
eeprom_buf = malloc(max_eeprom_size);
FILE *fp = fopen(filename, "rb");
if (fp == NULL)
{
printf ("Can't open eeprom file %s.\n", filename);
exit (-1);
}
my_eeprom_size = fread(eeprom_buf, 1, max_eeprom_size, fp);
fclose(fp);
if (my_eeprom_size < 128)
{
printf ("Can't read eeprom file %s.\n", filename);
exit (-1);
}
ftdi_set_eeprom_buf(ftdi, eeprom_buf, my_eeprom_size);
}
}
printf ("FTDI write eeprom: %d\n", ftdi_write_eeprom(ftdi));
libusb_reset_device(ftdi->usb_dev);
}
// Write to file?
if (filename != NULL && strlen(filename) > 0 && !cfg_getbool(cfg, "flash_raw"))
{
fp = fopen(filename, "w");
if (fp == NULL)
{
printf ("Can't write eeprom file.\n");
exit (-1);
}
else
printf ("Writing to file: %s\n", filename);
if (eeprom_buf == NULL)
eeprom_buf = malloc(my_eeprom_size);
ftdi_get_eeprom_buf(ftdi, eeprom_buf, my_eeprom_size);
fwrite(eeprom_buf, my_eeprom_size, 1, fp);
fclose(fp);
}
cleanup:
if (eeprom_buf)
free(eeprom_buf);
if (_read > 0 || _erase > 0 || _flash > 0)
{
printf("FTDI close: %d\n", ftdi_usb_close(ftdi));
}
ftdi_deinit (ftdi);
ftdi_free (ftdi);
cfg_free(cfg);
printf("\n");
return 0;
}
// DECORATE state block
#define ITEM_WPN_STATES "states"
#define ITEM_WPN_INHERITS "inherits"
// WeaponInfo Delta Keywords
#define ITEM_DELTA_NAME "name"
// Title properties
#define ITEM_WPN_TITLE_SUPER "superclass"
#define ITEM_WPN_TITLE_DEHNUM "dehackednum"
cfg_opt_t wpninfo_tprops[] =
{
CFG_STR(ITEM_WPN_TITLE_SUPER, nullptr, CFGF_NONE),
CFG_INT(ITEM_WPN_TITLE_DEHNUM, -1, CFGF_NONE),
CFG_END()
};
#define WEAPONINFO_FIELDS \
CFG_INT(ITEM_WPN_DEHNUM, -1, CFGF_NONE), \
CFG_STR(ITEM_WPN_AMMO, "", CFGF_NONE), \
CFG_STR(ITEM_WPN_UPSTATE, "S_NULL", CFGF_NONE), \
CFG_STR(ITEM_WPN_DOWNSTATE, "S_NULL", CFGF_NONE), \
CFG_STR(ITEM_WPN_READYSTATE, "S_NULL", CFGF_NONE), \
CFG_STR(ITEM_WPN_ATKSTATE, "S_NULL", CFGF_NONE), \
CFG_STR(ITEM_WPN_FLASHSTATE, "S_NULL", CFGF_NONE), \
CFG_STR(ITEM_WPN_HOLDSTATE, "S_NULL", CFGF_NONE), \
CFG_INT(ITEM_WPN_AMMOPERSHOT, 0, CFGF_NONE), \
CFG_STR(ITEM_WPN_AMMO_ALT, "", CFGF_NONE), \
CFG_STR(ITEM_WPN_ATKSTATE_ALT, "S_NULL", CFGF_NONE), \
int handle_lispd_config_file()
{
cfg_t *cfg = 0;
unsigned int i = 0;
unsigned n = 0;
int ret = 0;
static cfg_opt_t map_server_opts[] = {
CFG_STR("address", 0, CFGF_NONE),
CFG_INT("key-type", 0, CFGF_NONE),
CFG_STR("key", 0, CFGF_NONE),
CFG_BOOL("proxy-reply", cfg_false, CFGF_NONE),
CFG_BOOL("verify", cfg_false, CFGF_NONE),
CFG_END()
};
static cfg_opt_t db_mapping_opts[] = {
CFG_STR("eid-prefix", 0, CFGF_NONE),
CFG_INT("iid", -1, CFGF_NONE),
CFG_STR("interface", 0, CFGF_NONE),
CFG_INT("priority_v4", 0, CFGF_NONE),
CFG_INT("weight_v4", 0, CFGF_NONE),
CFG_INT("priority_v6", 0, CFGF_NONE),
CFG_INT("weight_v6", 0, CFGF_NONE),
CFG_END()
};
static cfg_opt_t mc_mapping_opts[] = {
CFG_STR("eid-prefix", 0, CFGF_NONE),
CFG_INT("iid", 0, CFGF_NONE),
CFG_STR("rloc", 0, CFGF_NONE),
CFG_INT("priority", 0, CFGF_NONE),
CFG_INT("weight", 0, CFGF_NONE),
CFG_END()
};
static cfg_opt_t petr_mapping_opts[] = {
CFG_STR("address", 0, CFGF_NONE),
CFG_INT("priority", 255, CFGF_NONE),
CFG_INT("weight", 0, CFGF_NONE),
CFG_END()
};
cfg_opt_t opts[] = {
CFG_SEC("database-mapping", db_mapping_opts, CFGF_MULTI),
CFG_SEC("static-map-cache", mc_mapping_opts, CFGF_MULTI),
CFG_SEC("map-server", map_server_opts, CFGF_MULTI),
CFG_SEC("proxy-etr", petr_mapping_opts, CFGF_MULTI),
CFG_INT("map-request-retries", 0, CFGF_NONE),
CFG_INT("control-port", 0, CFGF_NONE),
CFG_BOOL("debug", cfg_false, CFGF_NONE),
CFG_STR("map-resolver", 0, CFGF_NONE),
CFG_STR_LIST("proxy-itrs", 0, CFGF_NONE),
CFG_END()
};
/*
* parse config_file
*/
cfg = cfg_init(opts, CFGF_NOCASE);
ret = cfg_parse(cfg, config_file);
if (ret == CFG_FILE_ERROR) {
syslog(LOG_DAEMON, "Couldn't find config file %s, exiting...", config_file);
exit(EXIT_FAILURE);
} else if(ret == CFG_PARSE_ERROR) {
syslog(LOG_DAEMON, "NOTE: Version 0.2.4 changed the format of the 'proxy-etr' element.");
syslog(LOG_DAEMON, " Check the 'lispd.conf.example' file for an example entry in");
syslog(LOG_DAEMON, " the new format.");
syslog(LOG_DAEMON, "Parse error in file %s, exiting...", config_file);
exit(EXIT_FAILURE);
}
/*
* lispd config options
*/
ret = cfg_getint(cfg, "map-request-retries");
if (ret != 0)
map_request_retries = ret;
cfg_getbool(cfg, "debug") ? (debug = 1) : (debug = 0);
/*
* LISP config options
*/
/*
* handle map-resolver config
*/
map_resolver = cfg_getstr(cfg, "map-resolver");
if (!add_server(map_resolver, &map_resolvers))
return(0);
#ifdef DEBUG
syslog(LOG_DAEMON, "Added %s to map-resolver list", map_resolver);
#endif
/*
* handle proxy-etr config
*/
n = cfg_size(cfg, "proxy-etr");
for(i = 0; i < n; i++) {
cfg_t *petr = cfg_getnsec(cfg, "proxy-etr", i);
if (!add_proxy_etr_entry(petr, &proxy_etrs)) {
syslog(LOG_DAEMON, "Can't add proxy-etr %d (%s)", i, cfg_getstr(petr, "address"));
}
}
if (!proxy_etrs){
syslog(LOG_DAEMON, "WARNING: No Proxy-ETR defined. Packets to non-LISP destinations will be forwarded natively (no LISP encapsulation). This may prevent mobility in some scenarios.");
sleep(3);
}
/*
* handle proxy-itr config
*/
n = cfg_size(cfg, "proxy-itrs");
for(i = 0; i < n; i++) {
if ((proxy_itr = cfg_getnstr(cfg, "proxy-itrs", i)) != NULL) {
if (!add_server(proxy_itr, &proxy_itrs))
continue;
#ifdef DEBUG
syslog(LOG_DAEMON, "Added %s to proxy-itr list", proxy_itr);
#endif
}
}
/*
* handle database-mapping config
*/
n = cfg_size(cfg, "database-mapping");
for(i = 0; i < n; i++) {
cfg_t *dm = cfg_getnsec(cfg, "database-mapping", i);
if (!add_database_mapping(dm)) {
syslog(LOG_DAEMON, "Can't add database-mapping %d (%s->%s)",
i,
cfg_getstr(dm, "eid-prefix"),
cfg_getstr(dm, "interface"));
}
}
/*
* handle map-server config
*/
n = cfg_size(cfg, "map-server");
for(i = 0; i < n; i++) {
cfg_t *ms = cfg_getnsec(cfg, "map-server", i);
if (!add_map_server(cfg_getstr(ms, "address"),
cfg_getint(ms, "key-type"),
cfg_getstr(ms, "key"),
(cfg_getbool(ms, "proxy-reply") ? 1:0),
(cfg_getbool(ms, "verify") ? 1:0)))
return(0);
#ifdef DEBUG
syslog(LOG_DAEMON, "Added %s to map-server list",
cfg_getstr(ms, "address"));
#endif
}
/*
* handle static-map-cache config
*/
n = cfg_size(cfg, "static-map-cache");
for(i = 0; i < n; i++) {
cfg_t *smc = cfg_getnsec(cfg, "static-map-cache", i);
if (!add_static_map_cache_entry(smc)) {
syslog(LOG_DAEMON,"Can't add static-map-cache %d (EID:%s -> RLOC:%s)",
i,
cfg_getstr(smc, "eid-prefix"),
cfg_getstr(smc, "rloc"));
}
}
#if (DEBUG > 3)
dump_tree(AF_INET,AF4_database);
dump_tree(AF_INET6,AF6_database);
dump_database();
dump_map_servers();
dump_servers(map_resolvers, "map-resolvers");
dump_servers(proxy_etrs, "proxy-etrs");
dump_servers(proxy_itrs, "proxy-itrs");
dump_map_cache();
#endif
cfg_free(cfg);
return(0);
}
/*
* read configuration file
*/
int
read_config(struct program_params *pp)
{
static cfg_opt_t pv_opts[] = {
CFG_INT("tier", 0, CFGF_NONE),
CFG_FLOAT("pinningScore", 0, CFGF_NONE),
CFG_STR("path", NULL, CFGF_NONE),
CFG_INT_CB("maxUsedSpace", -1, CFGF_NONE, parse_size_value),
CFG_END()
};
static cfg_opt_t volume_opts[] = {
CFG_STR("LogicalVolume", NULL, CFGF_NONE),
CFG_STR("VolumeGroup", NULL, CFGF_NONE),
CFG_FLOAT("timeExponent", 1.0/(2<<14), CFGF_NONE),
CFG_FLOAT("hitScore", 16, CFGF_NONE),
CFG_FLOAT("readMultiplier", 1, CFGF_NONE),
CFG_FLOAT("writeMultiplier", 4, CFGF_NONE),
CFG_INT_CB("pvmoveWait", 5*60, CFGF_NONE, parse_time_value),
CFG_INT_CB("checkWait", 15*60, CFGF_NONE, parse_time_value),
CFG_SEC("pv", pv_opts, CFGF_TITLE | CFGF_MULTI),
CFG_END()
};
cfg_opt_t opts[] = {
CFG_SEC("volume", volume_opts, CFGF_TITLE | CFGF_MULTI),
CFG_END()
};
cfg_t *cfg;
cfg = cfg_init(opts, CFGF_NONE);
assert(cfg);
// add verification functions
cfg_set_validate_func(cfg, "volume|timeExponent",
validate_require_positive);
cfg_set_validate_func(cfg, "volume|hitScore",
validate_require_positive);
cfg_set_validate_func(cfg, "volume|readMultiplier",
validate_require_nonnegative);
cfg_set_validate_func(cfg, "volume|writeMultiplier",
validate_require_nonnegative);
cfg_set_validate_func(cfg, "volume|pv|pinningScore",
validate_require_nonnegative);
cfg_set_validate_func(cfg, "volume|pv|tier",
validate_require_nonnegative);
cfg_set_validate_func(cfg, "volume|pv|maxUsedSpace",
validate_require_nonnegative);
// TODO cfg_set_validate_func(cfg, "volume", validate_pv); // do they belong to volume, is there enough space
switch(cfg_parse(cfg, pp->conf_file_path)) {
case CFG_FILE_ERROR:
fprintf(stderr, "Configuration file \"%s\" could not be read: %s\n",
pp->conf_file_path, strerror(errno));
return 1;
case CFG_SUCCESS:
break;
case CFG_PARSE_ERROR:
fprintf(stderr, "Configuration file errors, aborting\n");
return 1;
default:
fprintf(stderr, "Internal error");
assert(0);
}
pp->cfg = cfg;
return 0;
}
#include "logger.h"
#include "misc.h"
#include "conffile.h"
/* Forward */
static int cb_loglevel(cfg_t *cfg, cfg_opt_t *opt, const char *value, void *result);
/* general section structure */
static cfg_opt_t sec_general[] =
{
CFG_STR("uid", "nobody", CFGF_NONE),
CFG_STR("admin_password", NULL, CFGF_NONE),
CFG_STR("logfile", STATEDIR "/log/" PACKAGE ".log", CFGF_NONE),
CFG_STR("db_path", STATEDIR "/cache/" PACKAGE "/songs3.db", CFGF_NONE),
CFG_INT("db_pragma_cache_size", -1, CFGF_NONE),
CFG_STR("db_pragma_journal_mode", NULL, CFGF_NONE),
CFG_INT("db_pragma_synchronous", -1, CFGF_NONE),
CFG_INT_CB("loglevel", E_LOG, CFGF_NONE, &cb_loglevel),
CFG_BOOL("ipv6", cfg_true, CFGF_NONE),
CFG_STR("cache_path", STATEDIR "/cache/" PACKAGE "/cache.db", CFGF_NONE),
CFG_INT("cache_daap_threshold", 1000, CFGF_NONE),
CFG_END()
};
/* library section structure */
static cfg_opt_t sec_library[] =
{
CFG_STR("name", "My Music on %h", CFGF_NONE),
CFG_INT("port", 3689, CFGF_NONE),
CFG_STR("password", NULL, CFGF_NONE),
int
configuration(struct app_parent *app_p,
const char *configfile,
char **policy_file,
char **syslog_ident,
int *syslog_flags,
int *syslog_facility) {
unsigned int i, j;
struct tq_listener_s *p_listener = NULL;
struct tq_service_s *p_service = NULL;
char *buf = NULL;
cfg_t *cfg;
cfg_t *syslog_sec;
unsigned n_listener, n_services;
int ret;
static cfg_opt_t syslog_opts[] = {
CFG_STR("ident", NULL, CFGF_NONE),
CFG_INT_CB("facility", NONE, CFGF_NONE, &cb_syslog_facility),
CFG_INT_LIST_CB("options", NULL, CFGF_NONE, &cb_syslog_options),
CFG_END()
};
static cfg_opt_t service_opts[] = {
CFG_INT_CB("type", NONE, CFGF_NONE, &cb_service_type),
CFG_STR("uri", 0, CFGF_NONE),
CFG_INT("threads", 4, CFGF_NONE),
CFG_END()
};
static cfg_opt_t listener_opts[] = {
CFG_STR("bindaddress", 0, CFGF_NONE),
CFG_INT("port", 9001, CFGF_NONE),
CFG_INT("backlog", 1024, CFGF_NONE),
CFG_STR("cert", 0, CFGF_NONE),
CFG_STR("key", 0, CFGF_NONE),
CFG_STR("cafile", 0, CFGF_NONE),
CFG_STR("capath", 0, CFGF_NONE),
CFG_STR("crlpath", 0, CFGF_NONE),
CFG_STR("password", 0, CFGF_NONE),
CFG_STR("cipherlist", 0, CFGF_NONE),
CFG_INT_CB("clientauth", NONE, CFGF_NONE, &cb_answer),
CFG_INT_CB("rfc3820", NONE, CFGF_NONE, &cb_answer),
CFG_STR("whitelist", 0, CFGF_NONE),
CFG_STR("blacklist", 0, CFGF_NONE),
CFG_SEC("service", service_opts, CFGF_MULTI),
CFG_END()
};
cfg_opt_t opts[] = {
CFG_INT_CB("debug", NONE, CFGF_NONE, &cb_answer),
CFG_STR("policyfile", 0, CFGF_NONE),
CFG_SEC("syslog", syslog_opts, CFGF_NONE),
CFG_SEC("listener", listener_opts, CFGF_MULTI),
CFG_END()
};
cfg = cfg_init(opts, CFGF_NOCASE);
/* set a validating callback function for bookmark sections */
/* cfg_set_validate_func(cfg, "bookmark", &cb_validate_bookmark); */
ret = cfg_parse(cfg, configfile);
if (ret == CFG_FILE_ERROR) {
fprintf(stderr, "Error: could not open or read the configuration file "
"\"%s\".\n", configfile);
return GA_BAD;
} else if (ret == CFG_PARSE_ERROR) {
fprintf(stderr, "Error: parse error in the configuration file "
"\"%s\".\n", configfile);
return GA_BAD;
}
/* Generic */
app_p->debug = cfg_getint(cfg, "debug");
if (app_p->debug == MAYBE || app_p->debug == OPTIONAL) {
printf("Overriding debug setting to 'yes'\n");
app_p->debug = YES;
} else if (app_p->debug == YES) {
printf("= Service running in DEBUG mode =\n");
}
/* XACML Rules file */
*policy_file = strdup(cfg_getstr(cfg, "policyfile"));
if (*policy_file == NULL) {
fprintf(stderr, "Error: no \"policyfile\" set in the configuration file\n");
return GA_BAD;
} else {
if (app_p->verbose) {
printf("Using XACML Policy file: \"%s\"\n", *policy_file);
}
}
/* Syslog */
syslog_sec = cfg_getsec(cfg, "syslog");
if (syslog_sec == NULL) {
fprintf(stderr, "Error: no \"syslog\" section found in the "
"configuration file \"%s\"\n", configfile);
} else {
*syslog_ident = strdup(cfg_getstr(syslog_sec, "ident"));
*syslog_facility = cfg_getint(syslog_sec, "facility");
if (app_p->debug == YES) {
printf("found syslog\n");
printf(" ident = %s\n", cfg_getstr(syslog_sec, "ident"));
printf(" facility = %ld\n", cfg_getint(syslog_sec, "facility"));
printf("BUG\n");
for (i = 0; i < cfg_size(syslog_sec, "options"); i++) {
printf("options[%d] == %ld\n", i, cfg_getnint(syslog_sec, "options", i));
}
printf("BUG\n");
}
/* Hardwired the settings */
*syslog_flags = LOG_PID|LOG_NDELAY;
if (app_p->verbose > 1) {
*syslog_flags |= LOG_PERROR;
}
}
/* Listeners */
n_listener = cfg_size(cfg, "listener");
if (app_p->verbose) {
printf("%d configured listeners:\n", n_listener);
}
for (i = 0; i < n_listener; i++) {
cfg_t *ls = cfg_getnsec(cfg, "listener", i);
if (ls == NULL) {
goto cleanup;
}
p_listener = malloc(sizeof(struct tq_listener_s));
if (p_listener == NULL) {
fprintf(stderr, "Error: memory allocation problem, couldn't allocate %lu bytes\n",
sizeof(struct tq_listener_s));
goto cleanup;
}
memset(p_listener, 0, sizeof(struct tq_listener_s));
TAILQ_INIT(&(p_listener->services_head));
/* Settings */
STRDUP_OR_GOTO_CLEANUP(p_listener->bindip, cfg_getstr(ls, "bindaddress"));
p_listener->port = (short)cfg_getint(ls, "port");
p_listener->backlog = (short)cfg_getint(ls, "backlog");
STRDUP_OR_GOTO_CLEANUP(p_listener->cert, cfg_getstr(ls, "cert"));
STRDUP_OR_GOTO_CLEANUP(p_listener->key, cfg_getstr(ls, "key"));
STRDUP_OR_GOTO_CLEANUP(p_listener->cafile, cfg_getstr(ls, "cafile"));
STRDUP_OR_GOTO_CLEANUP(p_listener->capath, cfg_getstr(ls, "capath"));
STRDUP_OR_GOTO_CLEANUP(p_listener->crlpath, cfg_getstr(ls, "crlpath"));
STRDUP_OR_GOTO_CLEANUP(p_listener->cipherlist, cfg_getstr(ls, "cipherlist") ?
cfg_getstr(ls, "cipherlist") :
"HIGH");
STRDUP_OR_GOTO_CLEANUP(p_listener->cert_password, cfg_getstr(ls, "password"));
STRDUP_OR_GOTO_CLEANUP(p_listener->whitelist_path, cfg_getstr(ls, "whitelist"));
STRDUP_OR_GOTO_CLEANUP(p_listener->blacklist_path, cfg_getstr(ls, "blacklist"));
p_listener->clientauth = (short)cfg_getint(ls, "clientauth");
p_listener->rfc3820 = (short)cfg_getint(ls, "rfc3820");
/* Normalizer */
if (p_listener->clientauth == MAYBE)
p_listener->clientauth = OPTIONAL;
if (p_listener->rfc3820 == MAYBE || p_listener->rfc3820 == OPTIONAL)
p_listener->rfc3820 = YES;
/* Create evhtp_ssl_cfg_t */
if (create_evhtp_ssl_cfg_from_tq_listener(p_listener) == GA_BAD) {
goto cleanup;
}
/* Services per listener */
n_services = cfg_size(ls, "service");
if (app_p->verbose) {
printf(" %d\n", n_services);
}
for (j = 0; j < n_services; j++) {
cfg_t *serv = cfg_getnsec(ls, "service", j);
if (serv == NULL) {
goto cleanup;
}
p_service = malloc(sizeof(struct tq_service_s));
if (p_service == NULL) {
fprintf(stderr, "Error: memory allocation problem, couldn't allocate %lu bytes\n",
sizeof(struct tq_service_s));
goto cleanup;
}
memset(p_service, 0, sizeof(struct tq_service_s));
p_service->parent_listener = p_listener;
/* Thread count override in Debug mode - max is 1 worker thread */
if (app_p->debug == YES) {
p_service->thread_cnt = 1;
} else {
p_service->thread_cnt = (short)cfg_getint(serv, "threads");
}
p_service->ltype = cfg_getint(serv, "type");
p_service->uri = cfg_getstr(serv, "uri");
if (p_service->uri && p_service->uri[0] == '/') {
p_service->uri = strdup(p_service->uri);
} else {
buf = malloc(strlen(p_service->uri) + 2);
if (buf == NULL) {
goto cleanup;
}
snprintf(buf, strlen(p_service->uri) + 2, "/%s", p_service->uri);
p_service->uri = buf;
}
if (app_p->verbose) {
printf(" uri = %s\n", p_service->uri);
printf(" type = %s\n", p_service->ltype == PDP ? "PDP" : p_service->ltype == PAP ? "PAP" : p_service->ltype == PEP ? "PEP" : "unknown");
}
TAILQ_INSERT_TAIL(&(p_listener->services_head), p_service, next);
}
TAILQ_INSERT_TAIL(&(app_p->listener_head), p_listener, next);
}
cfg_free(cfg);
return GA_GOOD;
cleanup:
cfg_free(cfg);
return GA_BAD;
}
