static int grok_config(char *path) { uint i; struct cfg_comp *config; if (!path) return 0; config = cfg_parse_file(path); if (!config) return 0; for (i = 0; i < config->vars; i++) { struct cfg_var *v = config->vlist[i]; if (!v->value) cfg_error(config, v, "No value for option '%s'", v->key); if (grok_common_var(config, v)) continue; if (!strcmp(v->key, "port")) { default_port = (unsigned short)strtoul(v->value, NULL, 0); continue; } cfg_warn(config, v, "Unrecognized variable\n"); } for (i = 0; i < config->nested; i++) { struct cfg_comp *c = config->nest[i]; if (!prefixcmp(c->name, "daemon")) { grok_daemon_compound(c); continue; } } /* * if we're supposed to kill a running daemon, ignore * parsing and post-processing nodes. We avoid memory * fragmentation by releasing the config memory before * allocating memory for the nodes. */ if (!killing) { node_grok_config(config); } cfg_destroy_compound(config); if (!killing) { post_process_nodes(); } return 1; }
isc_result_t irs_dnsconf_load(isc_mem_t *mctx, const char *filename, irs_dnsconf_t **confp) { irs_dnsconf_t *conf; cfg_parser_t *parser = NULL; cfg_obj_t *cfgobj = NULL; isc_result_t result = ISC_R_SUCCESS; REQUIRE(confp != NULL && *confp == NULL); conf = isc_mem_get(mctx, sizeof(*conf)); if (conf == NULL) return (ISC_R_NOMEMORY); conf->mctx = mctx; ISC_LIST_INIT(conf->trusted_keylist); /* * If the specified file does not exist, we'll simply with an empty * configuration. */ if (!isc_file_exists(filename)) goto cleanup; result = cfg_parser_create(mctx, NULL, &parser); if (result != ISC_R_SUCCESS) goto cleanup; result = cfg_parse_file(parser, filename, &cfg_type_dnsconf, &cfgobj); if (result != ISC_R_SUCCESS) goto cleanup; result = configure_dnsseckeys(conf, cfgobj, dns_rdataclass_in); cleanup: if (parser != NULL) { if (cfgobj != NULL) cfg_obj_destroy(parser, &cfgobj); cfg_parser_destroy(&parser); } conf->magic = IRS_DNSCONF_MAGIC; if (result == ISC_R_SUCCESS) *confp = conf; else irs_dnsconf_destroy(&conf); return (result); }
/*************************************************************************** * Called either from the "command-line" parser when it sees a --parm, * or from the "config-file" parser for normal options. ***************************************************************************/ void conf_set_parameter(struct Configuration *cfg, const char *name, const char *value) { unsigned index = ARRAY(name); if (index >= 8) { fprintf(stderr, "%s: bad index\n", name); exit(1); } if (EQUALS("conf", name) || EQUALS("config", name)) { cfg_parse_file(cfg, value); } else if (EQUALS("load-threads", name) || EQUALS("load-thread", name)) { cfg->loader.load_threads = (unsigned)parseInt(value); } else if (EQUALS("parse-threads", name) || EQUALS("parse-thread", name)) { cfg->loader.load_threads = (unsigned)parseInt(value); } else { fprintf(stderr, "CONF: unknown config option: %s=%s\n", name, value); } }
static isc_result_t get_rndckey(isc_mem_t *mctx, controlkeylist_t *keyids) { isc_result_t result; cfg_parser_t *pctx = NULL; cfg_obj_t *config = NULL; const cfg_obj_t *key = NULL; const cfg_obj_t *algobj = NULL; const cfg_obj_t *secretobj = NULL; const char *algstr = NULL; const char *secretstr = NULL; controlkey_t *keyid = NULL; char secret[1024]; unsigned int algtype; isc_buffer_t b; isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_CONTROL, ISC_LOG_INFO, "configuring command channel from '%s'", ns_g_keyfile); if (! isc_file_exists(ns_g_keyfile)) return (ISC_R_FILENOTFOUND); CHECK(cfg_parser_create(mctx, ns_g_lctx, &pctx)); CHECK(cfg_parse_file(pctx, ns_g_keyfile, &cfg_type_rndckey, &config)); CHECK(cfg_map_get(config, "key", &key)); keyid = isc_mem_get(mctx, sizeof(*keyid)); if (keyid == NULL) CHECK(ISC_R_NOMEMORY); keyid->keyname = isc_mem_strdup(mctx, cfg_obj_asstring(cfg_map_getname(key))); keyid->secret.base = NULL; keyid->secret.length = 0; keyid->algorithm = DST_ALG_UNKNOWN; ISC_LINK_INIT(keyid, link); if (keyid->keyname == NULL) CHECK(ISC_R_NOMEMORY); CHECK(bind9_check_key(key, ns_g_lctx)); (void)cfg_map_get(key, "algorithm", &algobj); (void)cfg_map_get(key, "secret", &secretobj); INSIST(algobj != NULL && secretobj != NULL); algstr = cfg_obj_asstring(algobj); secretstr = cfg_obj_asstring(secretobj); if (ns_config_getkeyalgorithm2(algstr, NULL, &algtype, NULL) != ISC_R_SUCCESS) { cfg_obj_log(key, ns_g_lctx, ISC_LOG_WARNING, "unsupported algorithm '%s' in " "key '%s' for use with command " "channel", algstr, keyid->keyname); goto cleanup; } keyid->algorithm = algtype; isc_buffer_init(&b, secret, sizeof(secret)); result = isc_base64_decodestring(secretstr, &b); if (result != ISC_R_SUCCESS) { cfg_obj_log(key, ns_g_lctx, ISC_LOG_WARNING, "secret for key '%s' on command channel: %s", keyid->keyname, isc_result_totext(result)); goto cleanup; } keyid->secret.length = isc_buffer_usedlength(&b); keyid->secret.base = isc_mem_get(mctx, keyid->secret.length); if (keyid->secret.base == NULL) { cfg_obj_log(key, ns_g_lctx, ISC_LOG_WARNING, "couldn't register key '%s': " "out of memory", keyid->keyname); CHECK(ISC_R_NOMEMORY); } memmove(keyid->secret.base, isc_buffer_base(&b), keyid->secret.length); ISC_LIST_APPEND(*keyids, keyid, link); keyid = NULL; result = ISC_R_SUCCESS; cleanup: if (keyid != NULL) free_controlkey(keyid, mctx); if (config != NULL) cfg_obj_destroy(pctx, &config); if (pctx != NULL) cfg_parser_destroy(&pctx); return (result); }
/*% The main processing routine */ int main(int argc, char **argv) { int c; cfg_parser_t *parser = NULL; cfg_obj_t *config = NULL; const char *conffile = NULL; isc_mem_t *mctx = NULL; isc_result_t result; int exit_status = 0; isc_entropy_t *ectx = NULL; isc_boolean_t load_zones = ISC_FALSE; isc_boolean_t print = ISC_FALSE; unsigned int flags = 0; isc_commandline_errprint = ISC_FALSE; /* * Process memory debugging argument first. */ #define CMDLINE_FLAGS "dhjm:t:pvxz" while ((c = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) { switch (c) { case 'm': if (strcasecmp(isc_commandline_argument, "record") == 0) isc_mem_debugging |= ISC_MEM_DEBUGRECORD; if (strcasecmp(isc_commandline_argument, "trace") == 0) isc_mem_debugging |= ISC_MEM_DEBUGTRACE; if (strcasecmp(isc_commandline_argument, "usage") == 0) isc_mem_debugging |= ISC_MEM_DEBUGUSAGE; if (strcasecmp(isc_commandline_argument, "size") == 0) isc_mem_debugging |= ISC_MEM_DEBUGSIZE; if (strcasecmp(isc_commandline_argument, "mctx") == 0) isc_mem_debugging |= ISC_MEM_DEBUGCTX; break; default: break; } } isc_commandline_reset = ISC_TRUE; RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS); while ((c = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != EOF) { switch (c) { case 'd': debug++; break; case 'j': nomerge = ISC_FALSE; break; case 'm': break; case 't': result = isc_dir_chroot(isc_commandline_argument); if (result != ISC_R_SUCCESS) { fprintf(stderr, "isc_dir_chroot: %s\n", isc_result_totext(result)); exit(1); } break; case 'p': print = ISC_TRUE; break; case 'v': printf(VERSION "\n"); exit(0); case 'x': flags |= CFG_PRINTER_XKEY; break; case 'z': load_zones = ISC_TRUE; docheckmx = ISC_FALSE; docheckns = ISC_FALSE; dochecksrv = ISC_FALSE; break; case '?': if (isc_commandline_option != '?') fprintf(stderr, "%s: invalid argument -%c\n", program, isc_commandline_option); /* FALLTHROUGH */ case 'h': usage(); default: fprintf(stderr, "%s: unhandled option -%c\n", program, isc_commandline_option); exit(1); } } if (((flags & CFG_PRINTER_XKEY) != 0) && !print) { fprintf(stderr, "%s: -x cannot be used without -p\n", program); exit(1); } if (isc_commandline_index + 1 < argc) usage(); if (argv[isc_commandline_index] != NULL) conffile = argv[isc_commandline_index]; if (conffile == NULL || conffile[0] == '\0') conffile = NAMED_CONFFILE; #ifdef _WIN32 InitSockets(); #endif RUNTIME_CHECK(setup_logging(mctx, stdout, &logc) == ISC_R_SUCCESS); RUNTIME_CHECK(isc_entropy_create(mctx, &ectx) == ISC_R_SUCCESS); RUNTIME_CHECK(isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE) == ISC_R_SUCCESS); dns_result_register(); RUNTIME_CHECK(cfg_parser_create(mctx, logc, &parser) == ISC_R_SUCCESS); cfg_parser_setcallback(parser, directory_callback, NULL); if (cfg_parse_file(parser, conffile, &cfg_type_namedconf, &config) != ISC_R_SUCCESS) exit(1); result = bind9_check_namedconf(config, logc, mctx); if (result != ISC_R_SUCCESS) exit_status = 1; if (result == ISC_R_SUCCESS && load_zones) { result = load_zones_fromconfig(config, mctx); if (result != ISC_R_SUCCESS) exit_status = 1; } if (print && exit_status == 0) cfg_printx(config, flags, output, NULL); cfg_obj_destroy(parser, &config); cfg_parser_destroy(&parser); dns_name_destroy(); isc_log_destroy(&logc); isc_hash_destroy(); isc_entropy_detach(&ectx); isc_mem_destroy(&mctx); #ifdef _WIN32 DestroySockets(); #endif return (exit_status); }
/*% The main processing routine */ int main(int argc, char **argv) { int c; cfg_parser_t *parser = NULL; cfg_obj_t *config = NULL; const char *conffile = NULL; isc_mem_t *mctx = NULL; isc_result_t result; int exit_status = 0; isc_entropy_t *ectx = NULL; isc_boolean_t load_zones = ISC_FALSE; isc_boolean_t print = ISC_FALSE; isc_commandline_errprint = ISC_FALSE; while ((c = isc_commandline_parse(argc, argv, "dhjt:pvz")) != EOF) { switch (c) { case 'd': debug++; break; case 'j': nomerge = ISC_FALSE; break; case 't': result = isc_dir_chroot(isc_commandline_argument); if (result != ISC_R_SUCCESS) { fprintf(stderr, "isc_dir_chroot: %s\n", isc_result_totext(result)); exit(1); } break; case 'p': print = ISC_TRUE; break; case 'v': printf(VERSION "\n"); exit(0); case 'z': load_zones = ISC_TRUE; docheckmx = ISC_FALSE; docheckns = ISC_FALSE; dochecksrv = ISC_FALSE; break; case '?': if (isc_commandline_option != '?') fprintf(stderr, "%s: invalid argument -%c\n", program, isc_commandline_option); case 'h': usage(); default: fprintf(stderr, "%s: unhandled option -%c\n", program, isc_commandline_option); exit(1); } } if (isc_commandline_index + 1 < argc) usage(); if (argv[isc_commandline_index] != NULL) conffile = argv[isc_commandline_index]; if (conffile == NULL || conffile[0] == '\0') conffile = NAMED_CONFFILE; #ifdef _WIN32 InitSockets(); #endif RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS); RUNTIME_CHECK(setup_logging(mctx, stdout, &logc) == ISC_R_SUCCESS); RUNTIME_CHECK(isc_entropy_create(mctx, &ectx) == ISC_R_SUCCESS); RUNTIME_CHECK(isc_hash_create(mctx, ectx, DNS_NAME_MAXWIRE) == ISC_R_SUCCESS); dns_result_register(); RUNTIME_CHECK(cfg_parser_create(mctx, logc, &parser) == ISC_R_SUCCESS); cfg_parser_setcallback(parser, directory_callback, NULL); if (cfg_parse_file(parser, conffile, &cfg_type_namedconf, &config) != ISC_R_SUCCESS) exit(1); result = bind9_check_namedconf(config, logc, mctx); if (result != ISC_R_SUCCESS) exit_status = 1; if (result == ISC_R_SUCCESS && load_zones) { result = load_zones_fromconfig(config, mctx); if (result != ISC_R_SUCCESS) exit_status = 1; } if (print && exit_status == 0) cfg_print(config, output, NULL); cfg_obj_destroy(parser, &config); cfg_parser_destroy(&parser); dns_name_destroy(); isc_log_destroy(&logc); isc_hash_destroy(); isc_entropy_detach(&ectx); isc_mem_destroy(&mctx); #ifdef _WIN32 DestroySockets(); #endif return (exit_status); }
static void parse_config(isc_mem_t *mctx, isc_log_t *log, const char *keyname, cfg_parser_t **pctxp, cfg_obj_t **configp) { isc_result_t result; const char *conffile = admin_conffile; cfg_obj_t *defkey = NULL; cfg_obj_t *options = NULL; cfg_obj_t *servers = NULL; cfg_obj_t *server = NULL; cfg_obj_t *keys = NULL; cfg_obj_t *key = NULL; cfg_obj_t *defport = NULL; cfg_obj_t *secretobj = NULL; cfg_obj_t *algorithmobj = NULL; cfg_obj_t *config = NULL; cfg_listelt_t *elt; const char *secretstr; const char *algorithm; static char secretarray[1024]; const cfg_type_t *conftype = &cfg_type_rndcconf; isc_boolean_t key_only = ISC_FALSE; if (! isc_file_exists(conffile)) { conffile = admin_keyfile; conftype = &cfg_type_rndckey; if (! isc_file_exists(conffile)) fatal("neither %s nor %s was found", admin_conffile, admin_keyfile); key_only = ISC_TRUE; } DO("create parser", cfg_parser_create(mctx, log, pctxp)); /* * The parser will output its own errors, so DO() is not used. */ result = cfg_parse_file(*pctxp, conffile, conftype, &config); if (result != ISC_R_SUCCESS) fatal("could not load rndc configuration"); if (!key_only) (void)cfg_map_get(config, "options", &options); if (key_only && servername == NULL) servername = "127.0.0.1"; else if (servername == NULL && options != NULL) { cfg_obj_t *defserverobj = NULL; (void)cfg_map_get(options, "default-server", &defserverobj); if (defserverobj != NULL) servername = cfg_obj_asstring(defserverobj); } if (servername == NULL) fatal("no server specified and no default"); if (!key_only) { (void)cfg_map_get(config, "server", &servers); if (servers != NULL) { for (elt = cfg_list_first(servers); elt != NULL; elt = cfg_list_next(elt)) { const char *name; server = cfg_listelt_value(elt); name = cfg_obj_asstring(cfg_map_getname(server)); if (strcasecmp(name, servername) == 0) break; server = NULL; } } } /* * Look for the name of the key to use. */ if (keyname != NULL) ; /* Was set on command line, do nothing. */ else if (server != NULL) { DO("get key for server", cfg_map_get(server, "key", &defkey)); keyname = cfg_obj_asstring(defkey); } else if (options != NULL) { DO("get default key", cfg_map_get(options, "default-key", &defkey)); keyname = cfg_obj_asstring(defkey); } else if (!key_only) fatal("no key for server and no default"); /* * Get the key's definition. */ if (key_only) DO("get key", cfg_map_get(config, "key", &key)); else { DO("get config key list", cfg_map_get(config, "key", &keys)); for (elt = cfg_list_first(keys); elt != NULL; elt = cfg_list_next(elt)) { key = cfg_listelt_value(elt); if (strcasecmp(cfg_obj_asstring(cfg_map_getname(key)), keyname) == 0) break; } if (elt == NULL) fatal("no key definition for name %s", keyname); } (void)cfg_map_get(key, "secret", &secretobj); (void)cfg_map_get(key, "algorithm", &algorithmobj); if (secretobj == NULL || algorithmobj == NULL) fatal("key must have algorithm and secret"); secretstr = cfg_obj_asstring(secretobj); algorithm = cfg_obj_asstring(algorithmobj); if (strcasecmp(algorithm, "hmac-md5") != 0) fatal("unsupported algorithm: %s", algorithm); secret.rstart = (unsigned char *)secretarray; secret.rend = (unsigned char *)secretarray + sizeof(secretarray); DO("decode base64 secret", isccc_base64_decode(secretstr, &secret)); secret.rend = secret.rstart; secret.rstart = (unsigned char *)secretarray; /* * Find the port to connect to. */ if (remoteport != 0) ; /* Was set on command line, do nothing. */ else { if (server != NULL) (void)cfg_map_get(server, "port", &defport); if (defport == NULL && options != NULL) (void)cfg_map_get(options, "default-port", &defport); } if (defport != NULL) { remoteport = cfg_obj_asuint32(defport); if (remoteport > 65535 || remoteport == 0) fatal("port %d out of range", remoteport); } else if (remoteport == 0) remoteport = NS_CONTROL_PORT; *configp = config; }
int main(int argc, char **argv) { isc_result_t result; isc_mem_t *mctx = NULL; isc_log_t *lctx = NULL; isc_logconfig_t *lcfg = NULL; isc_logdestination_t destination; cfg_parser_t *pctx = NULL; cfg_obj_t *cfg = NULL; cfg_type_t *type = NULL; isc_boolean_t grammar = ISC_FALSE; isc_boolean_t memstats = ISC_FALSE; char *filename = NULL; RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS); result = isc_log_create(mctx, &lctx, &lcfg); check_result(result, "isc_log_create()"); isc_log_setcontext(lctx); /* * Create and install the default channel. */ destination.file.stream = stderr; destination.file.name = NULL; destination.file.versions = ISC_LOG_ROLLNEVER; destination.file.maximum_size = 0; result = isc_log_createchannel(lcfg, "_default", ISC_LOG_TOFILEDESC, ISC_LOG_DYNAMIC, &destination, ISC_LOG_PRINTTIME); check_result(result, "isc_log_createchannel()"); result = isc_log_usechannel(lcfg, "_default", NULL, NULL); check_result(result, "isc_log_usechannel()"); /* * Set the initial debug level. */ isc_log_setdebuglevel(lctx, 2); if (argc < 3) usage(); while (argc > 1) { if (strcmp(argv[1], "--grammar") == 0) { grammar = ISC_TRUE; } else if (strcmp(argv[1], "--memstats") == 0) { memstats = ISC_TRUE; } else if (strcmp(argv[1], "--named") == 0) { type = &cfg_type_namedconf; } else if (strcmp(argv[1], "--rndc") == 0) { type = &cfg_type_rndcconf; } else if (argv[1][0] == '-') { usage(); } else { filename = argv[1]; } argv++, argc--; } if (grammar) { if (type == NULL) usage(); cfg_print_grammar(type, output, NULL); } else { if (type == NULL || filename == NULL) usage(); RUNTIME_CHECK(cfg_parser_create(mctx, lctx, &pctx) == ISC_R_SUCCESS); result = cfg_parse_file(pctx, filename, type, &cfg); fprintf(stderr, "read config: %s\n", isc_result_totext(result)); if (result != ISC_R_SUCCESS) exit(1); cfg_print(cfg, output, NULL); cfg_obj_destroy(pctx, &cfg); cfg_parser_destroy(&pctx); } isc_log_destroy(&lctx); if (memstats) isc_mem_stats(mctx, stderr); isc_mem_destroy(&mctx); fflush(stdout); if (ferror(stdout)) { fprintf(stderr, "write error\n"); return (1); } else return (0); }
void fbi_read_config(void) { init_config(); if (fbi_config) cfg_parse_file("config", fbi_config); }
static void parse_config(isc_mem_t *mctx, isc_log_t *log, const char *keyname, cfg_parser_t **pctxp, cfg_obj_t **configp) { isc_result_t result; const char *conffile = admin_conffile; const cfg_obj_t *addresses = NULL; const cfg_obj_t *defkey = NULL; const cfg_obj_t *options = NULL; const cfg_obj_t *servers = NULL; const cfg_obj_t *server = NULL; const cfg_obj_t *keys = NULL; const cfg_obj_t *key = NULL; const cfg_obj_t *defport = NULL; const cfg_obj_t *secretobj = NULL; const cfg_obj_t *algorithmobj = NULL; cfg_obj_t *config = NULL; const cfg_obj_t *address = NULL; const cfg_listelt_t *elt; const char *secretstr; const char *algorithm; static char secretarray[1024]; const cfg_type_t *conftype = &cfg_type_rndcconf; isc_boolean_t key_only = ISC_FALSE; const cfg_listelt_t *element; if (! isc_file_exists(conffile)) { conffile = admin_keyfile; conftype = &cfg_type_rndckey; if (! isc_file_exists(conffile)) fatal("neither %s nor %s was found", admin_conffile, admin_keyfile); key_only = ISC_TRUE; } DO("create parser", cfg_parser_create(mctx, log, pctxp)); /* * The parser will output its own errors, so DO() is not used. */ result = cfg_parse_file(*pctxp, conffile, conftype, &config); if (result != ISC_R_SUCCESS) fatal("could not load rndc configuration"); if (!key_only) (void)cfg_map_get(config, "options", &options); if (key_only && servername == NULL) servername = "127.0.0.1"; else if (servername == NULL && options != NULL) { const cfg_obj_t *defserverobj = NULL; (void)cfg_map_get(options, "default-server", &defserverobj); if (defserverobj != NULL) servername = cfg_obj_asstring(defserverobj); } if (servername == NULL) fatal("no server specified and no default"); if (!key_only) { (void)cfg_map_get(config, "server", &servers); if (servers != NULL) { for (elt = cfg_list_first(servers); elt != NULL; elt = cfg_list_next(elt)) { const char *name; server = cfg_listelt_value(elt); name = cfg_obj_asstring(cfg_map_getname(server)); if (strcasecmp(name, servername) == 0) break; server = NULL; } } } /* * Look for the name of the key to use. */ if (keyname != NULL) ; /* Was set on command line, do nothing. */ else if (server != NULL) { DO("get key for server", cfg_map_get(server, "key", &defkey)); keyname = cfg_obj_asstring(defkey); } else if (options != NULL) { DO("get default key", cfg_map_get(options, "default-key", &defkey)); keyname = cfg_obj_asstring(defkey); } else if (!key_only) fatal("no key for server and no default"); /* * Get the key's definition. */ if (key_only) DO("get key", cfg_map_get(config, "key", &key)); else { DO("get config key list", cfg_map_get(config, "key", &keys)); for (elt = cfg_list_first(keys); elt != NULL; elt = cfg_list_next(elt)) { key = cfg_listelt_value(elt); if (strcasecmp(cfg_obj_asstring(cfg_map_getname(key)), keyname) == 0) break; } if (elt == NULL) fatal("no key definition for name %s", keyname); } (void)cfg_map_get(key, "secret", &secretobj); (void)cfg_map_get(key, "algorithm", &algorithmobj); if (secretobj == NULL || algorithmobj == NULL) fatal("key must have algorithm and secret"); secretstr = cfg_obj_asstring(secretobj); algorithm = cfg_obj_asstring(algorithmobj); if (strcasecmp(algorithm, "hmac-md5") != 0) fatal("unsupported algorithm: %s", algorithm); secret.rstart = (unsigned char *)secretarray; secret.rend = (unsigned char *)secretarray + sizeof(secretarray); DO("decode base64 secret", isccc_base64_decode(secretstr, &secret)); secret.rend = secret.rstart; secret.rstart = (unsigned char *)secretarray; /* * Find the port to connect to. */ if (remoteport != 0) ; /* Was set on command line, do nothing. */ else { if (server != NULL) (void)cfg_map_get(server, "port", &defport); if (defport == NULL && options != NULL) (void)cfg_map_get(options, "default-port", &defport); } if (defport != NULL) { remoteport = cfg_obj_asuint32(defport); if (remoteport > 65535 || remoteport == 0) fatal("port %u out of range", remoteport); } else if (remoteport == 0) remoteport = NS_CONTROL_PORT; if (server != NULL) result = cfg_map_get(server, "addresses", &addresses); else result = ISC_R_NOTFOUND; if (result == ISC_R_SUCCESS) { for (element = cfg_list_first(addresses); element != NULL; element = cfg_list_next(element)) { isc_sockaddr_t sa; address = cfg_listelt_value(element); if (!cfg_obj_issockaddr(address)) { unsigned int myport; const char *name; const cfg_obj_t *obj; obj = cfg_tuple_get(address, "name"); name = cfg_obj_asstring(obj); obj = cfg_tuple_get(address, "port"); if (cfg_obj_isuint32(obj)) { myport = cfg_obj_asuint32(obj); if (myport > ISC_UINT16_MAX || myport == 0) fatal("port %u out of range", myport); } else myport = remoteport; if (nserveraddrs < SERVERADDRS) get_addresses(name, (in_port_t) myport); else fprintf(stderr, "too many address: " "%s: dropped\n", name); continue; } sa = *cfg_obj_assockaddr(address); if (isc_sockaddr_getport(&sa) == 0) isc_sockaddr_setport(&sa, remoteport); if (nserveraddrs < SERVERADDRS) serveraddrs[nserveraddrs++] = sa; else { char socktext[ISC_SOCKADDR_FORMATSIZE]; isc_sockaddr_format(&sa, socktext, sizeof(socktext)); fprintf(stderr, "too many address: %s: dropped\n", socktext); } } } if (!local4set && server != NULL) { address = NULL; cfg_map_get(server, "source-address", &address); if (address != NULL) { local4 = *cfg_obj_assockaddr(address); local4set = ISC_TRUE; } } if (!local4set && options != NULL) { address = NULL; cfg_map_get(options, "default-source-address", &address); if (address != NULL) { local4 = *cfg_obj_assockaddr(address); local4set = ISC_TRUE; } } if (!local6set && server != NULL) { address = NULL; cfg_map_get(server, "source-address-v6", &address); if (address != NULL) { local6 = *cfg_obj_assockaddr(address); local6set = ISC_TRUE; } } if (!local6set && options != NULL) { address = NULL; cfg_map_get(options, "default-source-address-v6", &address); if (address != NULL) { local6 = *cfg_obj_assockaddr(address); local6set = ISC_TRUE; } } *configp = config; }
void load_config_encode() { struct encodingoptions *point; struct machine *pointm; char filename[100]; char section[LONGOPT]; int have_config; sprintf(filename,"%s/%s/%s",getenv("HOME"),".studio", encodeconfigfile ); if (0 == cfg_parse_file(filename)) have_config = 1; point = &encoding; set_structs_default(point); /* set struct to the defaults */ point = &encoding2; set_structs_default(point); /* set struct to the defaults */ do_preset_mpeg2(point); /* set some mpeg2 specific options */ point = &encoding_gmpeg; set_structs_default(point); /* set struct to the defaults */ do_preset_mpeg2(point); /* set some mpeg2 specific options */ point = &encoding_vcd; set_structs_default(point); /* set struct to the defaults */ do_preset_vcd(point); /* set some VCD specific options */ point = &encoding_svcd; set_structs_default(point); /* set struct to the defaults */ do_preset_svcd(point); /* set some SVCD specific options */ point = &encoding_dvd; set_structs_default(point); /* set struct to the defaults */ do_preset_dvd(point); /* set some DVD specific options */ point = &encoding_yuv2lav; set_structs_default(point); /* set struct to the defaults */ do_preset_yuv2lav(point); /* set some DIVX specific options */ set_distributed(); /*set the distributed encoding variabels to the defaults*/ /* set the defaults for the scripting options */ set_scripting_defaults (); set_common(); load_common(); if (verbose) show_common(); strncpy(section,"MPEG1",LONGOPT); point = &encoding; load_section(section,point); if (verbose) print_encoding_options(section,point); strncpy(section,"MPEG2",LONGOPT); point = &encoding2; load_section(section,point); if (verbose) print_encoding_options(section,point); strncpy(section,"GENERIC",LONGOPT); point = &encoding_gmpeg; load_section(section,point); if (verbose) print_encoding_options(section,point); strncpy(section,"VCD",LONGOPT); point = &encoding_vcd; load_section(section,point); if (verbose) print_encoding_options(section,point); strncpy(section,"SVCD",LONGOPT); point = &encoding_svcd; load_section(section,point); if (verbose) print_encoding_options(section,point); strncpy(section,"DVD",LONGOPT); point = &encoding_dvd; load_section(section,point); if (verbose) print_encoding_options(section,point); strncpy(section,"YUV2LAV",LONGOPT); point = &encoding_yuv2lav; load_section(section,point); if (verbose) print_encoding_options(section,point); load_machine_names(); /* fill the GList with machine names */ if (verbose) print_machine_names(); strncpy(section,"Machines4MPEG1",LONGOPT); pointm = &machine4mpeg1; load_machine_data(section, pointm); if (verbose) print_machine_data(section,pointm); strncpy(section,"Machines4MPEG2",LONGOPT); pointm = &machine4mpeg2; load_machine_data(section, pointm); if (verbose) print_machine_data(section,pointm); strncpy(section,"Machines4GENERIC",LONGOPT); pointm = &machine4mpeg2; load_machine_data(section, pointm); if (verbose) print_machine_data(section,pointm); strncpy(section,"Machines4VCD",LONGOPT); pointm = &machine4vcd; load_machine_data(section, pointm); if (verbose) print_machine_data(section,pointm); strncpy(section,"Machines4SVCD",LONGOPT); pointm = &machine4svcd; load_machine_data(section, pointm); if (verbose) print_machine_data(section,pointm); strncpy(section,"Machines4DVD",LONGOPT); pointm = &machine4svcd; load_machine_data(section, pointm); if (verbose) print_machine_data(section,pointm); strncpy(section,"Machines4YUV2LAV",LONGOPT); pointm = &machine4yuv2lav; load_machine_data(section, pointm); if (verbose) print_machine_data(section,pointm); load_script_data(); }
static void load_options(int *width, int *height, int *x, int *y) { char *val; int i, num=0, tot; char filename[256]; char value_get[256]; sprintf(filename, "%s/%s", getenv("HOME"), ".studio"); chk_dir(filename); sprintf(filename, "%s/%s/%s.tv-conf",getenv("HOME"),".studio", tv_config_file); cfg_parse_file(filename); port = cfg_get_int("StudioTV", "default_port"); if (width) *width = cfg_get_int("StudioTV", "default_width"); if (height) *height = cfg_get_int("StudioTV", "default_height"); if (x) *x = cfg_get_int("StudioTV", "default_x"); if (y) *y = cfg_get_int("StudioTV", "default_y"); if ((encoding_id = cfg_get_int("StudioTV", "default_encoding_id"))==-1) encoding_id = 0; #ifdef OSS if (!mixer_dev) mixer_dev = cfg_get_str("StudioTV", "default_mixer_dev"); if (!mixer_dev) mixer_dev = "/dev/mixer"; audio_src = cfg_get_int("StudioTV", "default_audio_src"); #endif #ifdef HAVE_LIRC if (!lirc_dev) lirc_dev = cfg_get_str("StudioTV", "default_lirc_dev"); if (!lirc_dev) lirc_dev = "/dev/lircd"; for(num=0;num<RC_NUM_KEYS;num++) { sprintf(value_get, "remote_control_key_%d", num); remote_buttons[num] = cfg_get_str("StudioTV",value_get); if (!remote_buttons[num]) remote_buttons[num] = "none"; } #endif if ((tot = cfg_get_int("StudioTV", "num_chans")) < 1) return; if (channels) { for (i=0;channels[i];i++) free(channels[i]); free(channels); } channels = (Channel**)malloc(sizeof(Channel*)*(tot+1)); for(num=0;num<tot;num++) { sprintf(value_get, "channel_frequency_%d", num); i = cfg_get_int("StudioTV",value_get); sprintf(value_get, "channel_name_%d", num); val = cfg_get_str("StudioTV",value_get); channels[num] = (Channel*)malloc(sizeof(Channel)); channels[num]->frequency = i; sprintf(channels[num]->name, val); } channels[tot] = NULL; if (verbose) g_print("Configuration loaded from %s\n", filename); }
static isc_result_t setup_dnsseckeys(dns_client_t *client) { isc_result_t result; cfg_parser_t *parser = NULL; const cfg_obj_t *keys = NULL; const cfg_obj_t *managed_keys = NULL; cfg_obj_t *bindkeys = NULL; const char *filename = anchorfile; if (!root_validation && !dlv_validation) return (ISC_R_SUCCESS); if (filename == NULL) { #ifndef WIN32 filename = NS_SYSCONFDIR "/bind.keys"; #else static char buf[MAX_PATH]; strlcpy(buf, isc_ntpaths_get(SYS_CONF_DIR), sizeof(buf)); strlcat(buf, "\\bind.keys", sizeof(buf)); filename = buf; #endif } if (trust_anchor == NULL) { trust_anchor = isc_mem_strdup(mctx, "."); if (trust_anchor == NULL) fatal("out of memory"); } if (trust_anchor != NULL) CHECK(convert_name(&afn, &anchor_name, trust_anchor)); if (dlv_anchor != NULL) CHECK(convert_name(&dfn, &dlv_name, dlv_anchor)); CHECK(cfg_parser_create(mctx, dns_lctx, &parser)); if (access(filename, R_OK) != 0) { if (anchorfile != NULL) fatal("Unable to read key file '%s'", anchorfile); } else { result = cfg_parse_file(parser, filename, &cfg_type_bindkeys, &bindkeys); if (result != ISC_R_SUCCESS) if (anchorfile != NULL) fatal("Unable to load keys from '%s'", anchorfile); } if (bindkeys == NULL) { isc_buffer_t b; isc_buffer_init(&b, anchortext, sizeof(anchortext) - 1); isc_buffer_add(&b, sizeof(anchortext) - 1); result = cfg_parse_buffer(parser, &b, &cfg_type_bindkeys, &bindkeys); if (result != ISC_R_SUCCESS) fatal("Unable to parse built-in keys"); } INSIST(bindkeys != NULL); cfg_map_get(bindkeys, "trusted-keys", &keys); cfg_map_get(bindkeys, "managed-keys", &managed_keys); if (keys != NULL) CHECK(load_keys(keys, client)); if (managed_keys != NULL) CHECK(load_keys(managed_keys, client)); result = ISC_R_SUCCESS; if (trusted_keys == 0) fatal("No trusted keys were loaded"); if (dlv_validation) dns_client_setdlv(client, dns_rdataclass_in, dlv_anchor); cleanup: if (result != ISC_R_SUCCESS) delv_log(ISC_LOG_ERROR, "setup_dnsseckeys: %s", isc_result_totext(result)); return (result); }
int cfg_set_values() { int i; char *srv_ent; char *icy_ent; char *strtok_buf; char info_buf[256]; unsaved_changes = 0; if(cfg_parse_file(cfg_path) == -1) { snprintf(info_buf, sizeof(info_buf), "Missing config file %s", cfg_path); print_info(info_buf, 1); return 1; } cfg.audio.dev_num = cfg_get_int("audio", "device"); cfg.audio.samplerate = cfg_get_int("audio", "samplerate"); cfg.audio.resolution = 16; cfg.audio.bitrate = cfg_get_int("audio", "bitrate"); cfg.audio.channel = cfg_get_int("audio", "channel"); cfg.audio.codec = cfg_get_str("audio", "codec"); cfg.audio.pcm_list = snd_get_devices(&cfg.audio.dev_count); if(cfg.audio.samplerate == -1) cfg.audio.samplerate = 44100; if(cfg.audio.bitrate == -1) cfg.audio.bitrate = 128; if(cfg.audio.channel == -1) cfg.audio.channel = 2; if(cfg.audio.codec == NULL) { cfg.audio.codec = (char*)malloc(4*sizeof(char)); #ifdef HAVE_LIBLAME strcpy(cfg.audio.codec, "mp3"); #elif HAVE_LIBVORBIS strcpy(cfg.audio.codec, "ogg"); #else //error: but was compiled without ogg and mp3 support strcpy(cfg.audio.codec, "err"); #endif } //for config backward compability if(cfg.audio.dev_num >= cfg.audio.dev_count) cfg.audio.dev_num = 0; cfg.rec.bitrate = cfg_get_int("record", "bitrate"); cfg.rec.channel = cfg_get_int("record", "channel"); cfg.rec.samplerate = cfg_get_int("record", "samplerate"); cfg.rec.start_rec = cfg_get_int("record", "start_rec"); cfg.rec.codec = cfg_get_str("record", "codec"); cfg.rec.filename = cfg_get_str("record", "filename"); cfg.rec.folder = cfg_get_str("record", "folder"); if(cfg.rec.bitrate == -1) cfg.rec.bitrate = 192; if(cfg.rec.channel == -1) cfg.rec.channel = 2; if(cfg.rec.samplerate == -1) cfg.rec.samplerate = 44100; if(cfg.rec.start_rec == -1) cfg.rec.start_rec = 1; if(cfg.rec.codec == NULL) { cfg.rec.codec = (char*)malloc(4*sizeof(char)); #ifdef HAVE_LIBLAME strcpy(cfg.rec.codec, "mp3"); #elif HAVE_LIB_VORBIS strcpy(cfg.rec.codec, "ogg"); #else strcpy(cfg.rec.codec, "wav"); #endif } if(cfg.rec.filename == NULL) { cfg.rec.filename = (char*)malloc(strlen("rec_(%m_%d_%y)_%i.ext")+1); #ifdef HAVE_LIBLAME strcpy(cfg.rec.filename, "rec_(%m_%d_%y)_%i.mp3"); #elif HAVE_LIB_VORBIS strcpy(cfg.rec.filename, "rec_(%m_%d_%y)_%i.ogg"); #else strcpy(cfg.rec.filename, "rec_(%m_%d_%y)_%i.wav"); #endif } if(cfg.rec.folder == NULL) { cfg.rec.folder = (char*)malloc(3*sizeof(char)); strcpy(cfg.rec.folder, "./"); } cfg.main.num_of_srv = cfg_get_int("main", "num_of_srv"); if(cfg.main.num_of_srv > 0) { cfg.main.srv = cfg_get_str("main", "server"); cfg.main.srv_ent = cfg_get_str("main", "srv_ent"); cfg.srv = (server_t**)malloc(sizeof(server_t*) * cfg.main.num_of_srv); for(i = 0; i < cfg.main.num_of_srv; i++) cfg.srv[i] = (server_t*)malloc(sizeof(server_t)); srv_ent = (char*)malloc((MAX_SECTION_LENGTH+1) * sizeof(char)); strtok_buf = strdup(cfg.main.srv_ent); srv_ent = strtok(strtok_buf, ";"); for(i = 0; srv_ent != NULL; i++) { cfg.srv[i]->name = (char*)malloc((MAX_SECTION_LENGTH+1) * sizeof(char)); snprintf(cfg.srv[i]->name, MAX_SECTION_LENGTH, srv_ent); cfg.srv[i]->addr = cfg_get_str(srv_ent, "address"); cfg.srv[i]->port = cfg_get_int(srv_ent, "port"); cfg.srv[i]->pwd = cfg_get_str(srv_ent, "password"); cfg.srv[i]->type = cfg_get_int(srv_ent, "type"); cfg.srv[i]->mount = cfg_get_str(srv_ent, "mount"); if(cfg.srv[i]->type == -1) cfg.srv[i]->type = SHOUTCAST; if(!strcmp(cfg.srv[i]->name, cfg.main.srv)) cfg.selected_srv = i; srv_ent = strtok(NULL, ";"); } }// if(cfg.main.num_of_srv > 0) cfg.main.num_of_icy = cfg_get_int("main", "num_of_icy"); if(cfg.main.num_of_icy > 0) { cfg.main.icy = cfg_get_str("main", "icy"); cfg.main.icy_ent = cfg_get_str("main", "icy_ent"); //icy entries cfg.icy = (icy_t**)malloc(sizeof(icy_t*) * cfg.main.num_of_icy); for(i = 0; i < cfg.main.num_of_icy; i++) cfg.icy[i] = (icy_t*)malloc(sizeof(icy_t)); icy_ent = (char*)malloc(MAX_SECTION_LENGTH * sizeof(char)+1); strtok_buf = strdup(cfg.main.icy_ent); icy_ent = strtok(strtok_buf, ";"); for(i = 0; icy_ent != NULL; i++) { cfg.icy[i]->name = (char*)malloc(MAX_SECTION_LENGTH * sizeof(char)+1); snprintf(cfg.icy[i]->name, MAX_SECTION_LENGTH, icy_ent); cfg.icy[i]->desc = cfg_get_str(icy_ent, "description"); cfg.icy[i]->genre = cfg_get_str(icy_ent, "genre"); cfg.icy[i]->url = cfg_get_str(icy_ent, "url"); cfg.icy[i]->irc = cfg_get_str(icy_ent, "irc"); cfg.icy[i]->icq = cfg_get_str(icy_ent, "icq"); cfg.icy[i]->aim = cfg_get_str(icy_ent, "aim"); cfg.icy[i]->pub = cfg_get_str(icy_ent, "pub"); if(!strcmp(cfg.icy[i]->name, icy_ent)) cfg.selected_icy = i; icy_ent = strtok(NULL, ";"); } }//if(cfg.main.num_of_icy > 0) cfg.main.song_path = cfg_get_str("main", "song_path"); cfg.main.song_update = cfg_get_int("main", "song_update"); if(cfg.main.song_update == -1) cfg.main.song_update = 0; //song update from file is default off cfg.main.connect_at_startup = cfg_get_int("main", "connect_at_startup"); if(cfg.main.connect_at_startup == -1) cfg.main.connect_at_startup = 0; //read GUI stuff cfg.gui.attach = cfg_get_int("gui", "attach"); cfg.gui.ontop = cfg_get_int("gui", "ontop"); if(cfg.gui.attach == -1) cfg.gui.attach = 0; if(cfg.gui.ontop == -1) cfg.gui.ontop = 0; //read FLTK related stuff #if HAVE_FLTK cfg.main.bg_color = cfg_get_int("main", "bg_color"); if(cfg.main.bg_color == -1) cfg.main.bg_color = 151540480; //dark blue cfg.main.txt_color = cfg_get_int("main", "txt_color"); if(cfg.main.txt_color == -1) cfg.main.txt_color = -256; //white #endif return 0; }
/*************************************************************************** * Read the configuration from the command-line. * Called by 'main()' when starting up. ***************************************************************************/ void conf_command_line(struct Configuration *cfg, int argc, char *argv[]) { int i; struct ParsedIpAddress ipaddr; for (i=1; i<argc; i++) { /* * --name=value * --name:value * -- name value */ if (argv[i][0] == '-' && argv[i][1] == '-') { if (strcmp(argv[i], "--help") == 0) conf_help(); else { char name2[64]; char *name = argv[i] + 2; unsigned name_length; const char *value; value = strchr(&argv[i][2], '='); if (value == NULL) value = strchr(&argv[i][2], ':'); if (value == NULL) { value = argv[++i]; name_length = (unsigned)strlen(name); } else { name_length = (unsigned)(value - name); value++; } if (i >= argc) { fprintf(stderr, "%.*s: empty parameter\n", name_length, name); break; } if (name_length > sizeof(name2) - 1) { fprintf(stderr, "%.*s: name too long\n", name_length, name); name_length = sizeof(name2) - 1; } memcpy(name2, name, name_length); name2[name_length] = '\0'; conf_set_parameter(cfg, name2, value); } continue; } /* For for a single-dash parameter */ else if (argv[i][0] == '-') { const char *arg; switch (argv[i][1]) { case 'c': if (argv[i][2]) arg = argv[i]+2; else arg = argv[++i]; //conf_trackfile_add(cfg->tf, argv[i]); cfg_parse_file(cfg, argv[i]); break; case 'd': if (argv[i][2]) arg = argv[i]+2; else arg = argv[++i]; if (arg[0] < '0' || '9' < arg[0]) LOG_ERR(C_CONFIG, "expected numeric debug level after -d option\n"); else verbosity = atoi(arg); break; case 'i': if (argv[i][2]) arg = argv[i]+2; else arg = argv[++i]; conf_set_parameter(cfg, "adapter", arg); break; case 'h': case '?': conf_usage(); break; case 'v': verbosity++; break; default: LOG_ERR(C_CONFIG, "FAIL: unknown option: -%s\n", argv[i]); LOG_ERR(C_CONFIG, " [hint] try \"--help\"\n"); exit(1); } continue; } else if (ends_with(argv[i], ".zone")) cfg_add_zonefile(cfg, argv[i]); else if (ends_with(argv[i], ".conf")) { //conf_trackfile_add(cfg->tf, argv[i]); cfg_parse_file(cfg, argv[i]); } else if (parse_ip_address(argv[i], 0, 0, &ipaddr)) { ;//conf_set_parameter(conf, "adapter-ip", argv[i]); } else if (pixie_nic_exists(argv[i])) { //strcpy_s(conf->nic[0].ifname, sizeof(conf->nic[0].ifname), argv[i]); } else if (is_directory(argv[i]) && has_configuration(argv[i])) { //directory_to_zonefile_list(conf, argv[i]); } else { LOG_ERR(C_CONFIG, "%s: unknown command-line parameter\n", argv[i]); } } }