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]);
}
}
}