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(); }
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; }
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; }
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); }
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; }
/** Parse the configuration file with confuse * * \param config_fp The configuration file stream * \return Return true if parsing succeeded */ static bool parse_configuration_file(FILE *config_fp) { cfg_opt_t opts[] = { CFG_STR("rendering", "render", CFGF_NONE), CFG_STR_LIST("plugins", "{}", CFGF_NONE), CFG_END() }; globalconf.cfg = cfg_init(opts, CFGF_NONE); if(cfg_parse_fp(globalconf.cfg, config_fp) == CFG_PARSE_ERROR) return false; return true; }
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; }
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), CFG_STR("name", "NO_SCRIPT", CFGF_NONE), CFG_INT("id", 0, CFGF_NONE), CFG_INT("version", 0, CFGF_NONE), CFG_INT("unused1", 0, CFGF_NONE), CFG_INT_LIST("script", 0, CFGF_NONE), CFG_STR("comment", "", 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; }
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_CB("loglevel", E_LOG, CFGF_NONE, &cb_loglevel), CFG_BOOL("ipv6", cfg_true, 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), CFG_STR_LIST("directories", NULL, CFGF_NONE), CFG_STR_LIST("podcasts", NULL, CFGF_NONE), CFG_STR_LIST("compilations", NULL, CFGF_NONE), CFG_STR("compilation_artist", NULL, CFGF_NONE), CFG_STR("name_library", "Library", CFGF_NONE), CFG_STR("name_music", "Music", CFGF_NONE), CFG_STR("name_movies", "Movies", CFGF_NONE), CFG_STR("name_tvshows", "TV Shows", CFGF_NONE), CFG_STR("name_podcasts", "Podcasts", CFGF_NONE), CFG_STR_LIST("artwork_basenames", "{artwork,cover,Folder}", CFGF_NONE), CFG_STR_LIST("filetypes_ignore", "{.db,.ini}", CFGF_NONE), CFG_BOOL("itunes_overrides", cfg_false, CFGF_NONE), CFG_STR_LIST("no_transcode", NULL, CFGF_NONE), CFG_STR_LIST("force_transcode", NULL, CFGF_NONE), CFG_END() };
int handle_config_file(char **oor_conf_file) { int ret; cfg_t *cfg; char *mode; char *log_file; /* xTR specific */ 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_END() }; static cfg_opt_t rloc_address_opts[] = { CFG_STR("address", 0, CFGF_NONE), CFG_INT("priority", 0, CFGF_NONE), CFG_INT("weight", 0, CFGF_NONE), CFG_END() }; static cfg_opt_t rloc_iface_opts[] = { CFG_STR("interface", 0, CFGF_NONE), CFG_INT("ip_version", 0, CFGF_NONE), CFG_INT("priority", 0, CFGF_NONE), CFG_INT("weight", 0, CFGF_NONE), CFG_END() }; static cfg_opt_t db_mapping_opts[] = { CFG_STR("eid-prefix", 0, CFGF_NONE), CFG_INT("iid", 0, CFGF_NONE), CFG_SEC("rloc-address", rloc_address_opts, CFGF_MULTI), CFG_SEC("rloc-iface", rloc_iface_opts, CFGF_MULTI), CFG_END() }; static cfg_opt_t map_cache_mapping_opts[] = { CFG_STR("eid-prefix", 0, CFGF_NONE), CFG_INT("iid", 0, CFGF_NONE), CFG_SEC("rloc-address", rloc_address_opts, CFGF_MULTI), 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() }; static cfg_opt_t rtr_iface_opts[] = { CFG_STR("iface", 0, CFGF_NONE), CFG_INT("ip_version", 0, CFGF_NONE), CFG_INT("priority", 255, CFGF_NONE), CFG_INT("weight", 0, CFGF_NONE), CFG_END() }; static cfg_opt_t rtr_ifaces_opts[] = { CFG_SEC("rtr-iface", rtr_iface_opts, CFGF_MULTI), CFG_END() }; static cfg_opt_t nat_traversal_opts[] = { CFG_BOOL("nat_aware", cfg_false, CFGF_NONE), CFG_STR("site_ID", 0, CFGF_NONE), CFG_STR("xTR_ID", 0, CFGF_NONE), CFG_END() }; static cfg_opt_t rloc_probing_opts[] = { CFG_INT("rloc-probe-interval", 0, CFGF_NONE), CFG_INT("rloc-probe-retries", 0, CFGF_NONE), CFG_INT("rloc-probe-retries-interval", 0, CFGF_NONE), CFG_END() }; static cfg_opt_t elp_node_opts[] = { CFG_STR("address", 0, CFGF_NONE), CFG_BOOL("strict", cfg_false, CFGF_NONE), CFG_BOOL("probe", cfg_false, CFGF_NONE), CFG_BOOL("lookup", cfg_false, CFGF_NONE), CFG_END() }; static cfg_opt_t elp_opts[] = { CFG_STR("elp-name", 0, CFGF_NONE), CFG_SEC("elp-node", elp_node_opts, CFGF_MULTI), CFG_END() }; static cfg_opt_t rle_node_opts[] = { CFG_STR("address", 0, CFGF_NONE), CFG_INT("level", 0, CFGF_NONE), CFG_END() }; static cfg_opt_t rle_opts[] = { CFG_STR("rle-name", 0, CFGF_NONE), CFG_SEC("rle-node", rle_node_opts, CFGF_MULTI), CFG_END() }; static cfg_opt_t mc_info_opts[] = { CFG_STR("mc-info-name", 0, CFGF_NONE), CFG_STR("source", 0, CFGF_NONE), CFG_INT("source-mask-length", 0, CFGF_NONE), CFG_STR("group", 0, CFGF_NONE), CFG_INT("group-mask-length", 0, CFGF_NONE), CFG_INT("iid", 0, CFGF_NONE), CFG_END() }; /* Map-Server specific */ static cfg_opt_t lisp_site_opts[] = { CFG_STR("eid-prefix", 0, CFGF_NONE), CFG_INT("iid", 0, CFGF_NONE), CFG_INT("key-type", 0, CFGF_NONE), CFG_STR("key", 0, CFGF_NONE), CFG_BOOL("accept-more-specifics", cfg_false, CFGF_NONE), CFG_BOOL("proxy-reply", cfg_false, CFGF_NONE), CFG_BOOL("merge", cfg_false, CFGF_NONE), CFG_END() }; cfg_opt_t opts[] = { CFG_SEC("database-mapping", db_mapping_opts, CFGF_MULTI), CFG_SEC("ms-static-registered-site", db_mapping_opts, CFGF_MULTI), CFG_SEC("rtr-database-mapping", db_mapping_opts, CFGF_MULTI), CFG_SEC("static-map-cache", map_cache_mapping_opts, CFGF_MULTI), CFG_SEC("map-server", map_server_opts, CFGF_MULTI), CFG_SEC("rtr-ifaces", rtr_ifaces_opts, CFGF_MULTI), CFG_SEC("proxy-etr", petr_mapping_opts, CFGF_MULTI), CFG_SEC("nat-traversal", nat_traversal_opts, CFGF_MULTI), CFG_STR("encapsulation", 0, CFGF_NONE), CFG_SEC("rloc-probing", rloc_probing_opts, CFGF_MULTI), CFG_INT("map-request-retries", 0, CFGF_NONE), CFG_INT("control-port", 0, CFGF_NONE), CFG_INT("debug", 0, CFGF_NONE), CFG_STR("log-file", 0, CFGF_NONE), CFG_INT("rloc-probing-interval",0, CFGF_NONE), CFG_STR_LIST("map-resolver", 0, CFGF_NONE), CFG_STR_LIST("proxy-itrs", 0, CFGF_NONE), #ifdef ANDROID CFG_BOOL("override-dns", cfg_false, CFGF_NONE), CFG_STR("override-dns-primary", 0, CFGF_NONE), CFG_STR("override-dns-secondary", 0, CFGF_NONE), #endif CFG_STR("operating-mode", 0, CFGF_NONE), CFG_STR("control-iface", 0, CFGF_NONE), CFG_STR("rtr-data-iface", 0, CFGF_NONE), CFG_SEC("lisp-site", lisp_site_opts, CFGF_MULTI), CFG_SEC("explicit-locator-path", elp_opts, CFGF_MULTI), CFG_SEC("replication-list", rle_opts, CFGF_MULTI), CFG_SEC("multicast-info", mc_info_opts, CFGF_MULTI), CFG_END() }; if (*oor_conf_file == NULL){ *oor_conf_file = strdup("/etc/oor.conf"); } /* * parse config_file */ cfg = cfg_init(opts, CFGF_NOCASE); ret = cfg_parse(cfg, *oor_conf_file); if (ret == CFG_FILE_ERROR) { OOR_LOG(LCRIT, "Couldn't find config file %s, exiting...", config_file); exit_cleanup(); } else if(ret == CFG_PARSE_ERROR) { OOR_LOG(LCRIT, "Parse error in file %s, exiting. Check conf file (see oor.conf.example)", config_file); exit_cleanup(); } /* * oor config options */ /* Debug level */ if (debug_level == -1){ ret = cfg_getint(cfg, "debug"); if (ret > 0) debug_level = ret; else debug_level = 0; if (debug_level > 3) debug_level = 3; } if (debug_level == 1){ OOR_LOG (LINF, "Log level: Low debug"); }else if (debug_level == 2){ OOR_LOG (LINF, "Log level: Medium debug"); }else if (debug_level == 3){ OOR_LOG (LINF, "Log level: High Debug"); } /* * Log file */ log_file = cfg_getstr(cfg, "log-file"); if (daemonize == TRUE){ open_log_file(log_file); } mode = cfg_getstr(cfg, "operating-mode"); if (mode) { if (strcmp(mode, "xTR") == 0) { ret=configure_xtr(cfg); } else if (strcmp(mode, "MS") == 0) { ret=configure_ms(cfg); } else if (strcmp(mode, "RTR") == 0) { ret=configure_rtr(cfg); }else if (strcmp(mode, "MN") == 0) { ret=configure_mn(cfg); } } cfg_free(cfg); return(GOOD); }
/** * Main function of the user app that parses configuration file and sends it to * NAT64 kernel module. * * @param argc Qty of arguments in command line call. * @param argv Array of arguments in command line call. */ int main(int argc, char *argv[]) { struct stat sb; // To check if config file exist. struct in_addr iaddrn, iaddrf, iaddrl; // To validate IP addresses struct in6_addr i6addrf; // also cfg_t *cfg, *cfg_ipv4, *cfg_ipv6; const char *sect_name; char *addr_first, *addr_last; unsigned char addr_maskbits; int port_first, port_last; char which[sizeof("ABC")]; char str[INET_ADDRSTRLEN]; struct config_struct cs; struct nl_sock *nls; int ret; int i = 0; struct ipv6_prefixes **ipv6_pref = NULL; unsigned char ipv6_pref_qty; char ipv6_def_prefix64[sizeof("1111:2222:3333:4444:5555:6666::/128")]; char *ipv6_buf; char *ipv6_check_addr; char *ipv6_check_maskbits; if (argc != 2) { printf("Usage: %s <config-file>\n", argv[0]); exit(EXIT_FAILURE); } if ( stat(argv[1], &sb) == -1 ) { printf("Error: Can not open configuration file: %s\n", argv[1]); exit(EXIT_FAILURE); } // Load default configuration values for each config option, just in case // they were not included in the config file. cfg_opt_t ipv4_opts[] = { CFG_STR("ipv4_addr_net", IPV4_DEF_NET, CFGF_NONE), CFG_INT("ipv4_addr_net_mask_bits", IPV4_DEF_MASKBITS, CFGF_NONE), CFG_STR("ipv4_pool_range_first", IPV4_DEF_POOL_FIRST, CFGF_NONE), CFG_STR("ipv4_pool_range_last", IPV4_DEF_POOL_LAST, CFGF_NONE), CFG_INT("ipv4_tcp_port_range_first", IPV4_DEF_TCP_PORTS_FIRST, CFGF_NONE), CFG_INT("ipv4_tcp_port_range_last", IPV4_DEF_TCP_PORTS_LAST, CFGF_NONE), CFG_INT("ipv4_udp_port_range_first", IPV4_DEF_UDP_PORTS_FIRST, CFGF_NONE), CFG_INT("ipv4_udp_port_range_last", IPV4_DEF_UDP_PORTS_LAST, CFGF_NONE), CFG_END() }; // Load default configuration values for each config option, just in case // they were not included in the config file. sprintf(ipv6_def_prefix64, "%s/%d", IPV6_DEF_PREFIX, IPV6_DEF_MASKBITS ); cfg_opt_t ipv6_opts[] = { CFG_STR_LIST("ipv6_net_prefixes", ipv6_def_prefix64, CFGF_NONE), CFG_INT("ipv6_tcp_port_range_first", IPV6_DEF_TCP_PORTS_FIRST, CFGF_NONE), CFG_INT("ipv6_tcp_port_range_last", IPV6_DEF_TCP_PORTS_LAST, CFGF_NONE), CFG_INT("ipv6_udp_port_range_first", IPV6_DEF_UDP_PORTS_FIRST, CFGF_NONE), CFG_INT("ipv6_udp_port_range_last", IPV6_DEF_UDP_PORTS_LAST, CFGF_NONE), CFG_END() }; // Define two sections in config file cfg_opt_t opts[] = { CFG_SEC("ipv4", ipv4_opts, CFGF_NONE), CFG_SEC("ipv6", ipv6_opts, CFGF_NONE), CFG_END() }; // Parse config file cfg = cfg_init(opts, CFGF_NONE); if(cfg_parse(cfg, argv[1]) == CFG_PARSE_ERROR) { printf("Error parsing configuration file: %s\n", argv[1]); exit_error_conf(cfg); } /* * Loading IPv4 configuration * */ { cfg_ipv4 = cfg_getsec(cfg, "ipv4"); sect_name = cfg_name(cfg_ipv4); printf ("Section: %s\n", sect_name); // Validate IPv4 pool address addr_first = cfg_getstr(cfg_ipv4, "ipv4_addr_net"); if ( convert_ipv4_addr(addr_first, &iaddrn) == EXIT_FAILURE ) { printf("Error: Invalid IPv4 address net: %s\n", addr_first); exit_error_conf(cfg); } // Validate netmask bits addr_maskbits = cfg_getint(cfg_ipv4, "ipv4_addr_net_mask_bits"); if ( validate_ipv4_netmask_bits(addr_maskbits) == EXIT_FAILURE ) { printf("Error: Bad IPv4 network mask bits value: %d\n", addr_maskbits); exit_error_conf(cfg); } // Store values in config struct cs.ipv4_addr_net = iaddrn; cs.ipv4_addr_net_mask_bits = addr_maskbits; printf("\tPool Network: %s/%d\n", addr_first, addr_maskbits); // Validate pool addresses range addr_first = cfg_getstr(cfg_ipv4, "ipv4_pool_range_first"); addr_last = cfg_getstr(cfg_ipv4, "ipv4_pool_range_last"); if ( convert_ipv4_addr(addr_first, &iaddrf) == EXIT_FAILURE ) // Validate ipv4 addr { printf("Error: Malformed ipv4_pool_range_first: %s\n", addr_first); exit_error_conf(cfg); } if ( convert_ipv4_addr(addr_last, &iaddrl) == EXIT_FAILURE ) // Validate ipv4 addr { printf("Error: Malformed ipv4_pool_range_last: %s\n", addr_last); exit_error_conf(cfg); } if ( validate_ipv4_pool_range(&iaddrn, addr_maskbits, &iaddrf, &iaddrl) == EXIT_FAILURE ) // Validate that: first < last { printf("Error: Pool addresses badly defined.\n"); exit_error_conf(cfg); } // Store values in config struct cs.ipv4_pool_range_first = iaddrf; cs.ipv4_pool_range_last = iaddrl; inet_ntop(AF_INET, &(iaddrf.s_addr), str, INET_ADDRSTRLEN); printf("\t\t- First address: %s\n", str); inet_ntop(AF_INET, &(iaddrl.s_addr), str, INET_ADDRSTRLEN); printf("\t\t- Last address: %s\n", str); // Validate port ranges port_first = cfg_getint(cfg_ipv4, "ipv4_tcp_port_range_first"); port_last = cfg_getint(cfg_ipv4, "ipv4_tcp_port_range_last"); sprintf(which, "TCP"); if ( validate_ports_range(port_first, port_last) == EXIT_FAILURE ) { //~ printf("Error: Invalid first %s port: %d\n", which, port_first); printf("Error: Invalid %s ports range.\n", which); exit_error_conf(cfg); } cs.ipv4_tcp_port_first = port_first; cs.ipv4_tcp_port_last = port_last; printf("\t%s pool port range: %d-%d\n", which, port_first, port_last); // port_first = cfg_getint(cfg_ipv4, "ipv4_udp_port_range_first"); port_last = cfg_getint(cfg_ipv4, "ipv4_udp_port_range_last"); sprintf(which, "UDP"); if ( validate_ports_range(port_first, port_last) == EXIT_FAILURE ) { printf("Error: Invalid %s ports range.\n", which); exit_error_conf(cfg); } cs.ipv4_udp_port_first = port_first; cs.ipv4_udp_port_last = port_last; printf("\t%s pool port range: %d-%d\n", which, port_first, port_last); printf ("\n" ); } /* * Loading IPv6 configuration * */ { cfg_ipv6 = cfg_getsec(cfg, "ipv6"); sect_name = cfg_name(cfg_ipv6); printf ("Section: %s\n", sect_name ); // Get number of IPv6 prefixes. ipv6_pref_qty = cfg_size(cfg_ipv6, "ipv6_net_prefixes"); // Allocate memory for the array of prefixes. ipv6_pref = (struct ipv6_prefixes **) malloc(ipv6_pref_qty * sizeof(struct ipv6_prefixes *)); for(i = 0; i < ipv6_pref_qty; i++) { // Split prefix and netmask bits ipv6_buf = cfg_getnstr(cfg_ipv6, "ipv6_net_prefixes", i); ipv6_check_addr = strtok(ipv6_buf, "/"); ipv6_check_maskbits = strtok(NULL, "/"); // Validate IPv6 addr if ( convert_ipv6_addr(ipv6_check_addr, &i6addrf) == EXIT_FAILURE ) { printf("Error: Invalid IPv6 address net: %s\n", ipv6_check_addr); exit_error_conf(cfg); } // Validate netmask bits addr_maskbits = atoi(ipv6_check_maskbits); if ( validate_ipv6_netmask_bits(addr_maskbits) == EXIT_FAILURE ) { printf("Error: Bad IPv6 network mask bits value: %d\n", addr_maskbits); exit_error_conf(cfg); } // Allocate memory for each IPv6 prefix ipv6_pref[i] = (struct ipv6_prefixes *) malloc(sizeof(struct ipv6_prefixes)); ipv6_pref[i]->addr = (i6addrf); ipv6_pref[i]->maskbits = addr_maskbits; } // Store prefixes in the config struct cs.ipv6_net_prefixes = ipv6_pref; cs.ipv6_net_prefixes_qty = ipv6_pref_qty; // Validate port ranges port_first = cfg_getint(cfg_ipv6, "ipv6_tcp_port_range_first"); port_last = cfg_getint(cfg_ipv6, "ipv6_tcp_port_range_last"); sprintf(which, "TCP"); if ( validate_ports_range(port_first, port_last) == EXIT_FAILURE ) { printf("Error: Invalid %s ports range.\n", which); exit_error_conf(cfg); } cs.ipv6_tcp_port_range_first = port_first; cs.ipv6_tcp_port_range_last = port_last; printf("\t%s pool port range: %d-%d\n", which, port_first, port_last); // port_first = cfg_getint(cfg_ipv6, "ipv6_udp_port_range_first"); port_last = cfg_getint(cfg_ipv6, "ipv6_udp_port_range_last"); sprintf(which, "UDP"); if ( validate_ports_range(port_first, port_last) == EXIT_FAILURE ) { printf("Error: Invalid %s ports range.\n", which); exit_error_conf(cfg); } cs.ipv6_udp_port_range_first = port_first; cs.ipv6_udp_port_range_last = port_last; printf("\t%s pool port range: %d-%d\n", which, port_first, port_last); printf ("\n" ); } cfg_free(cfg); /* We got the configuration structure, now send it to the module * using netlink sockets. */ // Reserve memory for netlink socket nls = nl_socket_alloc(); if (!nls) { printf("bad nl_socket_alloc\n"); return EXIT_FAILURE; } // Bind and connect the socket to kernel ret = nl_connect(nls, NETLINK_USERSOCK); if (ret < 0) { nl_perror(ret, "nl_connect"); nl_socket_free(nls); return EXIT_FAILURE; } // Send socket to module ret = nl_send_simple(nls, MSG_TYPE_CONF, 0, &(cs), sizeof(cs)); if (ret < 0) { nl_perror(ret, "nl_send_simple"); printf("Error sending message, is module loaded?\n"); nl_close(nls); nl_socket_free(nls); return EXIT_FAILURE; } else { printf("Message sent (%d bytes):\n", ret); //print_nat64_run_conf(nrc); } nl_close(nls); nl_socket_free(nls); exit(EXIT_SUCCESS); }
CFG_INT("size", 60, CFGF_NONE), CFG_STR("type", "64bit", CFGF_NONE), CFG_END() }; static cfg_opt_t attr_opts[] = { CFG_STR("description", "", CFGF_NONE), CFG_STR("unit", "", CFGF_NONE), CFG_STR("type", "counter", CFGF_NONE), CFG_BOOL("history", cfg_false, CFGF_NONE), CFG_END() }; static cfg_opt_t variant_opts[] = { CFG_FLOAT_LIST("div", "{}", CFGF_NONE), CFG_STR_LIST("txt", "", CFGF_NONE), CFG_END() }; static cfg_opt_t unit_opts[] = { CFG_SEC("variant", variant_opts, CFGF_MULTI | CFGF_TITLE), CFG_END() }; static cfg_opt_t global_opts[] = { CFG_FLOAT("read_interval", 1.0f, CFGF_NONE), CFG_FLOAT("rate_interval", 1.0f, CFGF_NONE), CFG_FLOAT("lifetime", 30.0f, CFGF_NONE), CFG_FLOAT("history_variance", 0.1f, CFGF_NONE), CFG_FLOAT("variance", 0.1f, CFGF_NONE), CFG_BOOL("show_all", cfg_false, 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); }
int xbps_init(struct xbps_handle *xhp) { cfg_opt_t vpkg_opts[] = { CFG_STR_LIST(__UNCONST("targets"), NULL, CFGF_NONE), CFG_END() }; cfg_opt_t opts[] = { /* Defaults if not set in configuration file */ CFG_STR(__UNCONST("rootdir"), __UNCONST("/"), CFGF_NONE), CFG_STR(__UNCONST("cachedir"), __UNCONST(XBPS_CACHE_PATH), CFGF_NONE), CFG_INT(__UNCONST("FetchCacheConnections"), XBPS_FETCH_CACHECONN, CFGF_NONE), CFG_INT(__UNCONST("FetchCacheConnectionsPerHost"), XBPS_FETCH_CACHECONN_HOST, CFGF_NONE), CFG_INT(__UNCONST("FetchTimeoutConnection"), XBPS_FETCH_TIMEOUT, CFGF_NONE), CFG_INT(__UNCONST("TransactionFrequencyFlush"), XBPS_TRANS_FLUSH, CFGF_NONE), CFG_BOOL(__UNCONST("syslog"), true, CFGF_NONE), CFG_STR_LIST(__UNCONST("repositories"), NULL, CFGF_MULTI), CFG_STR_LIST(__UNCONST("PackagesOnHold"), NULL, CFGF_MULTI), CFG_SEC(__UNCONST("virtual-package"), vpkg_opts, CFGF_MULTI|CFGF_TITLE), CFG_FUNC(__UNCONST("include"), &cfg_include), CFG_END() }; struct utsname un; int rv, cc, cch; bool syslog_enabled = false; assert(xhp != NULL); if (xhp->initialized) return 0; if (xhp->conffile == NULL) xhp->conffile = XBPS_CONF_DEF; /* parse configuration file */ xhp->cfg = cfg_init(opts, CFGF_NOCASE); cfg_set_validate_func(xhp->cfg, "virtual-package", &cb_validate_virtual); if ((rv = cfg_parse(xhp->cfg, xhp->conffile)) != CFG_SUCCESS) { if (rv == CFG_FILE_ERROR) { /* * Don't error out if config file not found. * If a default repository is set, use it; otherwise * use defaults (no repos and no virtual packages). */ if (errno != ENOENT) return rv; xhp->conffile = NULL; if (xhp->repository) { char *buf; buf = xbps_xasprintf("repositories = { %s }", xhp->repository); assert(buf); if ((rv = cfg_parse_buf(xhp->cfg, buf)) != 0) return rv; free(buf); } } else if (rv == CFG_PARSE_ERROR) { /* * Parser error from configuration file. */ return ENOTSUP; } } xbps_dbg_printf(xhp, "Configuration file: %s\n", xhp->conffile ? xhp->conffile : "not found"); /* * Respect client setting in struct xbps_handle for {root,cache}dir; * otherwise use values from configuration file or defaults if unset. */ if (xhp->rootdir == NULL) { if (xhp->cfg == NULL) xhp->rootdir = "/"; else xhp->rootdir = cfg_getstr(xhp->cfg, "rootdir"); } if (xhp->cachedir == NULL) { if (xhp->cfg == NULL) xhp->cachedir = XBPS_CACHE_PATH; else xhp->cachedir = cfg_getstr(xhp->cfg, "cachedir"); } if ((xhp->cachedir_priv = set_cachedir(xhp)) == NULL) return ENOMEM; xhp->cachedir = xhp->cachedir_priv; if ((xhp->metadir_priv = set_metadir(xhp)) == NULL) return ENOMEM; xhp->metadir = xhp->metadir_priv; uname(&un); xhp->un_machine = strdup(un.machine); assert(xhp->un_machine); if (xhp->cfg == NULL) { xhp->flags |= XBPS_FLAG_SYSLOG; xhp->fetch_timeout = XBPS_FETCH_TIMEOUT; xhp->transaction_frequency_flush = XBPS_TRANS_FLUSH; cc = XBPS_FETCH_CACHECONN; cch = XBPS_FETCH_CACHECONN_HOST; } else { if (cfg_getbool(xhp->cfg, "syslog")) xhp->flags |= XBPS_FLAG_SYSLOG; xhp->fetch_timeout = cfg_getint(xhp->cfg, "FetchTimeoutConnection"); cc = cfg_getint(xhp->cfg, "FetchCacheConnections"); cch = cfg_getint(xhp->cfg, "FetchCacheConnectionsPerHost"); xhp->transaction_frequency_flush = cfg_getint(xhp->cfg, "TransactionFrequencyFlush"); } if (xhp->flags & XBPS_FLAG_SYSLOG) syslog_enabled = true; xbps_fetch_set_cache_connection(cc, cch); xbps_dbg_printf(xhp, "Rootdir=%s\n", xhp->rootdir); xbps_dbg_printf(xhp, "Metadir=%s\n", xhp->metadir); xbps_dbg_printf(xhp, "Cachedir=%s\n", xhp->cachedir); xbps_dbg_printf(xhp, "FetchTimeout=%u\n", xhp->fetch_timeout); xbps_dbg_printf(xhp, "FetchCacheconn=%u\n", cc); xbps_dbg_printf(xhp, "FetchCacheconnHost=%u\n", cch); xbps_dbg_printf(xhp, "Syslog=%u\n", syslog_enabled); xbps_dbg_printf(xhp, "TransactionFrequencyFlush=%u\n", xhp->transaction_frequency_flush); xbps_dbg_printf(xhp, "Architecture: %s\n", xhp->un_machine); xhp->initialized = true; return 0; }
int main(int argc, char *argv[]) { uint8_t threadid_main = 0; pthread_key_create(&threadid_key, NULL); pthread_setspecific(threadid_key, &threadid_main); mprintf("University of Wisconsin IPMI MicroTCA System Manager\n"); if (argc > 1 && strcmp(argv[1], "--version") == 0) { mprintf("\nCompiled from %s@%s\n", (GIT_BRANCH[0] ? GIT_BRANCH : "git-archive"), (GIT_COMMIT[0] ? GIT_COMMIT : "27868b9b800d107fbb53b68c2fce207144f97a98")); if (strlen(GIT_DIRTY) > 1) mprintf("%s", GIT_DIRTY); mprintf("\n"); return 0; } /* * Parse Configuration */ cfg_opt_t opts_auth[] = { CFG_STR_LIST(const_cast<char *>("raw"), const_cast<char *>("{}"), CFGF_NONE), CFG_STR_LIST(const_cast<char *>("manage"), const_cast<char *>("{}"), CFGF_NONE), CFG_STR_LIST(const_cast<char *>("read"), const_cast<char *>("{}"), CFGF_NONE), CFG_END() }; cfg_opt_t opts_crate[] = { CFG_STR(const_cast<char *>("host"), const_cast<char *>(""), CFGF_NONE), CFG_STR(const_cast<char *>("description"), const_cast<char *>(""), CFGF_NONE), CFG_STR(const_cast<char *>("username"), const_cast<char *>(""), CFGF_NONE), CFG_STR(const_cast<char *>("password"), const_cast<char *>(""), CFGF_NONE), CFG_INT_CB(const_cast<char *>("authtype"), 0, CFGF_NONE, cfg_parse_authtype), CFG_INT_CB(const_cast<char *>("mch"), 0, CFGF_NONE, cfg_parse_MCH), CFG_BOOL(const_cast<char *>("enabled"), cfg_true, CFGF_NONE), CFG_END() }; cfg_opt_t opts_cardmodule[] = { CFG_STR(const_cast<char *>("module"), const_cast<char *>(""), CFGF_NONE), CFG_STR_LIST(const_cast<char *>("config"), const_cast<char *>("{}"), CFGF_NONE), CFG_END() }; cfg_opt_t opts[] = { CFG_SEC(const_cast<char *>("authentication"), opts_auth, CFGF_NONE), CFG_SEC(const_cast<char *>("crate"), opts_crate, CFGF_MULTI), CFG_SEC(const_cast<char *>("cardmodule"), opts_cardmodule, CFGF_MULTI), CFG_INT(const_cast<char *>("socket_port"), 4681, CFGF_NONE), CFG_INT(const_cast<char *>("ratelimit_delay"), 0, CFGF_NONE), CFG_BOOL(const_cast<char *>("daemonize"), cfg_false, CFGF_NONE), CFG_END() }; cfg_t *cfg = cfg_init(opts, CFGF_NONE); cfg_set_validate_func(cfg, "crate|host", &cfg_validate_hostname); cfg_set_validate_func(cfg, "socket_port", &cfg_validate_port); if (argc >= 2 && access(argv[1], R_OK) == 0) { if(cfg_parse(cfg, argv[1]) == CFG_PARSE_ERROR) exit(1); } else if (access(CONFIG_PATH "/" CONFIG_FILE, R_OK) == 0) { if(cfg_parse(cfg, CONFIG_PATH "/" CONFIG_FILE) == CFG_PARSE_ERROR) exit(1); } else { printf("Config file %s not found, and no argument supplied.\n", CONFIG_PATH "/" CONFIG_FILE); printf("Try: %s sysmgr.conf\n", argv[0]); exit(1); } bool crate_found = false; bool crate_enabled = false; cfg_t *cfgauth = cfg_getsec(cfg, "authentication"); for(unsigned int i = 0; i < cfg_size(cfgauth, "raw"); i++) config_authdata.raw.push_back(std::string(cfg_getnstr(cfgauth, "raw", i))); for(unsigned int i = 0; i < cfg_size(cfgauth, "manage"); i++) config_authdata.manage.push_back(std::string(cfg_getnstr(cfgauth, "manage", i))); for(unsigned int i = 0; i < cfg_size(cfgauth, "read"); i++) config_authdata.read.push_back(std::string(cfg_getnstr(cfgauth, "read", i))); for(unsigned int i = 0; i < cfg_size(cfg, "crate"); i++) { cfg_t *cfgcrate = cfg_getnsec(cfg, "crate", i); crate_found = true; enum Crate::Mfgr MCH; switch (cfg_getint(cfgcrate, "mch")) { case Crate::VADATECH: MCH = Crate::VADATECH; break; case Crate::NAT: MCH = Crate::NAT; break; } const char *user = cfg_getstr(cfgcrate, "username"); const char *pass = cfg_getstr(cfgcrate, "password"); Crate *crate = new Crate(i+1, MCH, cfg_getstr(cfgcrate, "host"), (user[0] ? user : NULL), (pass[0] ? pass : NULL), cfg_getint(cfgcrate, "authtype"), cfg_getstr(cfgcrate, "description")); bool enabled = (cfg_getbool(cfgcrate, "enabled") == cfg_true); if (enabled) crate_enabled = true; threadlocal.push_back(threadlocaldata_t(crate, enabled)); } for(unsigned int i = 0; i < cfg_size(cfg, "cardmodule"); i++) { cfg_t *cfgmodule = cfg_getnsec(cfg, "cardmodule", i); const char *module = cfg_getstr(cfgmodule, "module"); std::vector<std::string> configdata; for(unsigned int i = 0; i < cfg_size(cfgmodule, "config"); i++) configdata.push_back(std::string(cfg_getnstr(cfgmodule, "config", i))); std::string default_module_path = DEFAULT_MODULE_PATH; if (getenv("SYSMGR_MODULE_PATH") != NULL) default_module_path = getenv("SYSMGR_MODULE_PATH"); std::string modulepath = module; if (modulepath.find("/") == std::string::npos) modulepath = default_module_path +"/"+ modulepath; cardmodule_t cm; cm.dl_addr = dlopen(modulepath.c_str(), RTLD_NOW|RTLD_GLOBAL); if (cm.dl_addr == NULL) { printf("Error loading module %s:\n\t%s\n", module, dlerror()); exit(2); } void *sym; #define LOAD_SYM(name, type) \ sym = dlsym(cm.dl_addr, #name); \ if (sym == NULL) { \ mprintf("Error loading module %s " type " " #name ":\n\t%s\n", module, dlerror()); \ exit(2); \ } LOAD_SYM(APIVER, "variable"); cm.APIVER = *reinterpret_cast<uint32_t*>(sym); LOAD_SYM(MIN_APIVER, "variable"); cm.MIN_APIVER = *reinterpret_cast<uint32_t*>(sym); if (cm.APIVER < 2 || cm.MIN_APIVER > 2) { mprintf("Error loading module %s: Incompatible API version %u\n", module, cm.APIVER); } LOAD_SYM(initialize_module, "function"); cm.initialize_module = reinterpret_cast<bool (*)(std::vector<std::string>)>(sym); LOAD_SYM(instantiate_card, "function"); cm.instantiate_card = reinterpret_cast<Card* (*)(Crate*, std::string, void*, uint8_t)>(sym); #undef LOAD_SYM if (!cm.initialize_module(configdata)) { printf("Error loading module %s: initialize_module() returned false\n", module); exit(2); } card_modules.insert(card_modules.begin(), cm); } uint16_t port = cfg_getint(cfg, "socket_port"); config_ratelimit_delay = cfg_getint(cfg, "ratelimit_delay"); bool daemonize = (cfg_getbool(cfg, "daemonize") == cfg_true); cfg_free(cfg); if (!crate_found) { printf("No crate specified in the configuration file.\n"); exit(1); } if (!crate_enabled) { printf("No crates are enabled in the configuration file.\n"); printf("No crates to service.\n"); exit(1); } if (daemonize) { do_fork(); stdout_use_syslog = true; mprintf("University of Wisconsin IPMI MicroTCA System Manager\n"); } /* * Initialize library crypto routines before spawning threads. * This connect will fail due to hostname too long, after running the crypt init functions. * * Max Hostname Limit: 64 */ ipmi_ctx_t dummy_ipmi_ctx = ipmi_ctx_create(); if (ipmi_ctx_open_outofband_2_0(dummy_ipmi_ctx, ".................................................................", // hostname NULL, // username NULL, // password NULL, // k_g 0, // k_g_len, 4, // privilege_level 0, // cipher_suite_id 0, // session_timeout 5, // retransmission_timeout IPMI_WORKAROUND_FLAGS_OUTOFBAND_2_0_OPEN_SESSION_PRIVILEGE, // workaround_flags IPMI_FLAGS_DEFAULT // flags ) == 0) { ipmi_ctx_close(dummy_ipmi_ctx); } ipmi_ctx_destroy(dummy_ipmi_ctx); /* * Instantiate Worker Threads */ for (std::vector<threadlocaldata_t>::iterator it = threadlocal.begin(); it != threadlocal.end(); it++) if (it->enabled) pthread_create(&it->thread, NULL, crate_monitor, (void *)it->crate->get_number()); #ifndef DEBUG_ONESHOT protocol_server(port); #endif for (std::vector<threadlocaldata_t>::iterator it = threadlocal.begin(); it != threadlocal.end(); it++) if (it->enabled) pthread_join(it->thread, NULL); }
/* used to keep track of to-be-needed rlimit information, to be used later to * determine if the system settings can handle what is configured. */ static rproxy_rusage_t _rusage = { 0, 0, 0 }; static cfg_opt_t ssl_crl_opts[] = { CFG_STR("file", NULL, CFGF_NONE), CFG_STR("dir", NULL, CFGF_NONE), CFG_INT_LIST("reload", "{ 10, 0 }", CFGF_NONE), CFG_END() }; static cfg_opt_t ssl_opts[] = { CFG_BOOL("enabled", cfg_false, CFGF_NONE), CFG_STR_LIST("protocols-on", "{ALL}", CFGF_NONE), CFG_STR_LIST("protocols-off", NULL, CFGF_NONE), CFG_STR("cert", NULL, CFGF_NONE), CFG_STR("key", NULL, CFGF_NONE), CFG_STR("ca", NULL, CFGF_NONE), CFG_STR("capath", NULL, CFGF_NONE), CFG_STR("ciphers", DEFAULT_CIPHERS, CFGF_NONE), CFG_BOOL("verify-peer", cfg_false, CFGF_NONE), CFG_BOOL("enforce-peer-cert", cfg_false, CFGF_NONE), CFG_INT("verify-depth", 0, CFGF_NONE), CFG_INT("context-timeout", 172800, CFGF_NONE), CFG_BOOL("cache-enabled", cfg_true, CFGF_NONE), CFG_INT("cache-timeout", 1024, CFGF_NONE), CFG_INT("cache-size", 65535, CFGF_NONE), CFG_SEC("crl", ssl_crl_opts, CFGF_NODEFAULT), CFG_END()
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_CB("loglevel", E_LOG, CFGF_NONE, &cb_loglevel), CFG_BOOL("ipv6", cfg_true, 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), CFG_STR_LIST("directories", NULL, CFGF_NONE), CFG_STR_LIST("exclude_directories", NULL, CFGF_NONE), CFG_STR_LIST("compilations", NULL, CFGF_NONE), CFG_BOOL("itunes_overrides", cfg_false, CFGF_NONE), CFG_STR_LIST("no_transcode", NULL, CFGF_NONE), CFG_STR_LIST("force_transcode", NULL, CFGF_NONE), CFG_END() }; /* local audio section structure */ static cfg_opt_t sec_audio[] = { CFG_STR("nickname", "Computer", CFGF_NONE), #ifdef __linux__ CFG_STR("card", "default", CFGF_NONE), #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
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_CB("loglevel", E_LOG, CFGF_NONE, &cb_loglevel), CFG_BOOL("ipv6", cfg_true, 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), CFG_STR_LIST("directories", NULL, CFGF_NONE), CFG_STR_LIST("compilations", NULL, CFGF_NONE), CFG_STR_LIST("artwork_basenames", "{artwork,cover}", CFGF_NONE), CFG_BOOL("itunes_overrides", cfg_false, CFGF_NONE), CFG_STR_LIST("no_transcode", NULL, CFGF_NONE), CFG_STR_LIST("force_transcode", NULL, CFGF_NONE), CFG_END() }; /* local audio section structure */ static cfg_opt_t sec_audio[] = { CFG_STR("nickname", "Computer", CFGF_NONE), #ifdef __linux__ CFG_STR("card", "default", CFGF_NONE), #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
int parse_input(char* file, globals* vars) { cfg_opt_t operation_opts[] = { CFG_STR_LIST("in","{}", CFGF_NONE), CFG_STR("out", 0, CFGF_NONE), CFG_END() }; cfg_opt_t opts[] = { CFG_STR_LIST("sorts", "{}", CFGF_NONE), CFG_SEC("op", operation_opts, CFGF_MULTI | CFGF_TITLE), CFG_FUNC("include", &cfg_include), CFG_END() }; cfg_t *cfg; int i, j, N, err; char *found, *sortname, *opname; op_signature *ops = malloc(sizeof(op_signature)+sizeof(char*)*MAX_OP_INPUTS); assert(ops); cfg = cfg_init(opts, CFGF_NONE); assert(cfg); if (cfg_parse(cfg, file) == CFG_PARSE_ERROR) return 1; /** * add new sort names to the sorts trie */ N = cfg_size(cfg, "sorts"); for (i = 0; i < N; i++) { sortname = cfg_getnstr(cfg, "sorts", i); found = cp_trie_exact_match(vars->sorts, sortname); if (!found) { sortname = strdup(sortname); cp_trie_add(vars->sorts, sortname, sortname); vars->sorts_N += 1; } } /** * the the operations to the operation list */ N = cfg_size(cfg, "op"); for (i = 0; i < N; i++) { cfg_t *op = cfg_getnsec(cfg, "op", i); opname = strdup(cfg_title(op)); cp_vector_add_element(vars->op_names, opname); sortname = cfg_getstr(op,"out"); assert(sortname); found = cp_trie_exact_match(vars->sorts,sortname); if (! found) { fputs("Operation ",stderr); fputs(opname,stderr); fputs(" uses undeclared output sort ",stderr); fputs(sortname,stderr); fputs("\n",stderr); /** fix it */ sortname = strdup(sortname); cp_trie_add(vars->sorts, sortname, sortname); vars->sorts_N += 1; found = sortname; } ops->id = vars->ops_N; ops->out = found; ops->in_N = cfg_size(op, "in"); assert(ops->in_N <= MAX_OP_INPUTS); for (j=0;j<ops->in_N; ++j) { sortname = cfg_getnstr(op,"in",j); assert(sortname); found = cp_trie_exact_match(vars->sorts,sortname); if (! found) { fputs("Operation ",stderr); fputs(opname,stderr); fputs(" uses undeclared input sort ",stderr); fputs(sortname,stderr); fputs("\n",stderr); /** fix it */ sortname = strdup(sortname); cp_trie_add(vars->sorts, sortname, sortname); vars->sorts_N += 1; found = sortname; } ops->in[j] = found; } err = 0; cp_multimap_insert(vars->ops, ops, &err); if (err) { fputs("Operation ",stderr); fputs(opname,stderr); fputs(": cannot add to multimap ",stderr); fprintf(stderr,"%d",err); fputs("\n",stderr); } vars->ops_N += 1; } cfg_free(cfg); free(ops); return 0; }
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), CFG_STR_LIST("directories", NULL, CFGF_NONE), CFG_STR_LIST("podcasts", NULL, CFGF_NONE), CFG_STR_LIST("audiobooks", NULL, CFGF_NONE), CFG_STR_LIST("compilations", NULL, CFGF_NONE), CFG_STR("compilation_artist", NULL, CFGF_NONE), CFG_BOOL("hide_singles", cfg_false, CFGF_NONE), CFG_BOOL("radio_playlists", cfg_false, CFGF_NONE), CFG_STR("name_library", "Library", CFGF_NONE), CFG_STR("name_music", "Music", CFGF_NONE), CFG_STR("name_movies", "Movies", CFGF_NONE), CFG_STR("name_tvshows", "TV Shows", CFGF_NONE), CFG_STR("name_podcasts", "Podcasts", CFGF_NONE), CFG_STR("name_audiobooks", "Audiobooks", CFGF_NONE), CFG_STR("name_radio", "Radio", CFGF_NONE), CFG_STR_LIST("artwork_basenames", "{artwork,cover,Folder}", CFGF_NONE), CFG_BOOL("artwork_individual", cfg_false, CFGF_NONE),
int main(int argc, char **argv) { unsigned int i; cfg_t *cfg; unsigned n; int ret; cfg_opt_t proxy_opts[] = { CFG_INT("type", 0, CFGF_NONE), CFG_STR("host", 0, CFGF_NONE), CFG_STR_LIST("exclude", "{localhost, .localnet}", CFGF_NONE), CFG_INT("port", 21, CFGF_NONE), CFG_END() }; cfg_opt_t bookmark_opts[] = { CFG_STR("machine", 0, CFGF_NONE), CFG_INT("port", 21, CFGF_NONE), CFG_STR("login", 0, CFGF_NONE), CFG_STR("password", 0, CFGF_NONE), CFG_STR("directory", 0, CFGF_NONE), CFG_BOOL("passive-mode", cfg_false, CFGF_NONE), CFG_SEC("proxy", proxy_opts, CFGF_NONE), CFG_END() }; cfg_opt_t opts[] = { CFG_INT("backlog", 42, CFGF_NONE), CFG_STR("probe-device", "eth2", CFGF_NONE), CFG_SEC("bookmark", bookmark_opts, CFGF_MULTI | CFGF_TITLE), CFG_FLOAT_LIST("delays", "{3.567e2, 0.2, -47.11}", CFGF_NONE), CFG_FUNC("func", &cb_func), CFG_INT_CB("ask-quit", 3, CFGF_NONE, &cb_verify_ask), CFG_INT_LIST_CB("ask-quit-array", "{maybe, yes, no}", CFGF_NONE, &cb_verify_ask), CFG_FUNC("include", &cfg_include), CFG_END() }; #ifndef _WIN32 /* for some reason, MS Visual C++ chokes on this (?) */ printf("Using %s\n\n", confuse_copyright); #endif 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, argc > 1 ? argv[1] : "test.conf"); printf("ret == %d\n", ret); if(ret == CFG_FILE_ERROR) { perror("test.conf"); return 1; } else if(ret == CFG_PARSE_ERROR) { fprintf(stderr, "parse error\n"); return 2; } printf("backlog == %ld\n", cfg_getint(cfg, "backlog")); printf("probe device is %s\n", cfg_getstr(cfg, "probe-device")); cfg_setstr(cfg, "probe-device", "lo"); printf("probe device is %s\n", cfg_getstr(cfg, "probe-device")); n = cfg_size(cfg, "bookmark"); printf("%d configured bookmarks:\n", n); for(i = 0; i < n; i++) { cfg_t *pxy; cfg_t *bm = cfg_getnsec(cfg, "bookmark", i); printf(" bookmark #%u (%s):\n", i+1, cfg_title(bm)); printf(" machine = %s\n", cfg_getstr(bm, "machine")); printf(" port = %d\n", (int)cfg_getint(bm, "port")); printf(" login = %s\n", cfg_getstr(bm, "login")); printf(" passive-mode = %s\n", cfg_getbool(bm, "passive-mode") ? "true" : "false"); printf(" directory = %s\n", cfg_getstr(bm, "directory")); printf(" password = %s\n", cfg_getstr(bm, "password")); pxy = cfg_getsec(bm, "proxy"); if(pxy) { int j, m; if(cfg_getstr(pxy, "host") == 0) { printf(" no proxy host is set, setting it to 'localhost'...\n"); /* For sections without CFGF_MULTI flag set, there is * also an extended syntax to get an option in a * subsection: */ cfg_setstr(bm, "proxy|host", "localhost"); } printf(" proxy host is %s\n", cfg_getstr(pxy, "host")); printf(" proxy type is %ld\n", cfg_getint(pxy, "type")); printf(" proxy port is %ld\n", cfg_getint(pxy, "port")); m = cfg_size(pxy, "exclude"); printf(" got %d hosts to exclude from proxying:\n", m); for(j = 0; j < m; j++) { printf(" exclude %s\n", cfg_getnstr(pxy, "exclude", j)); } } else printf(" no proxy settings configured\n"); } printf("delays are (%d):\n", cfg_size(cfg, "delays")); for(i = 0; i < cfg_size(cfg, "delays"); i++) printf(" %G\n", cfg_getnfloat(cfg, "delays", i)); printf("ask-quit == %ld\n", cfg_getint(cfg, "ask-quit")); /* Using cfg_setint(), the integer value for the option ask-quit * is not verified by the value parsing callback. * * cfg_setint(cfg, "ask-quit", 4); printf("ask-quit == %ld\n", cfg_getint(cfg, "ask-quit")); */ /* The following commented line will generate a failed assertion * and abort, since the option "foo" is not declared * * printf("foo == %ld\n", cfg_getint(cfg, "foo")); */ cfg_addlist(cfg, "ask-quit-array", 2, 1, 2); for(i = 0; i < cfg_size(cfg, "ask-quit-array"); i++) printf("ask-quit-array[%d] == %ld\n", i, cfg_getnint(cfg, "ask-quit-array", i)); /* print the parsed values to another file */ { FILE *fp = fopen("test.conf.out", "w"); cfg_set_print_func(cfg, "func", print_func); cfg_set_print_func(cfg, "ask-quit", print_ask); cfg_set_print_func(cfg, "ask-quit-array", print_ask); cfg_print(cfg, fp); fclose(fp); } cfg_free(cfg); return 0; }