void mtev_dso_init(void) {
mtev_conf_section_t *sections;
int i, cnt = 0;
mtev_dso_add_type("loader", mtev_dso_list_loaders);
mtev_dso_add_type("generic", mtev_dso_list_generics);
/* Load our generic modules */
sections = mtev_conf_get_sections(MTEV_CONF_ROOT, "//modules//generic", &cnt);
for(i=0; i<cnt; i++) {
char g_name[256];
mtev_dso_generic_t *gen;
mtev_conf_section_t *include_sections = NULL;
int section_cnt;
if(!mtev_conf_get_stringbuf(sections[i], "ancestor-or-self::node()/@name",
g_name, sizeof(g_name))) {
mtevL(mtev_stderr, "No name defined in generic stanza %d\n", i+1);
continue;
}
if(mtev_conf_env_off(sections[i], NULL)) {
mtevL(mtev_debug, "generic module %s environmentally disabled.\n", g_name);
continue;
}
gen = (mtev_dso_generic_t *)
mtev_load_generic_image(&__mtev_image_loader, g_name,
sections[i]);
if(!gen) {
mtevL(mtev_stderr, "Failed to load generic %s\n", g_name);
mtev_dso_load_failure_count++;
continue;
}
if(gen->config) {
int rv;
mtev_hash_table *config;
include_sections = mtev_conf_get_sections(sections[i], "include", §ion_cnt);
if ((include_sections) && (section_cnt == 1)) {
config = mtev_conf_get_hash(*include_sections, "config");
}
else {
config = mtev_conf_get_hash(sections[i], "config");
}
mtev_conf_release_sections(include_sections, section_cnt);
rv = gen->config(gen, config);
if(rv == 0) {
mtev_hash_destroy(config, free, free);
free(config);
}
else if(rv < 0) {
mtevL(mtev_stderr, "Failed to config generic %s\n", g_name);
continue;
}
}
if(gen->init && gen->init(gen)) {
mtevL(mtev_stderr, "Failed to init generic %s\n", g_name);
mtev_dso_load_failure_count++;
}
else
mtevL(mtev_debug, "Generic module %s successfully loaded.\n", g_name);
}
mtev_conf_release_sections(sections, cnt);
/* Load our module loaders */
sections = mtev_conf_get_sections(MTEV_CONF_ROOT, "//modules//loader", &cnt);
for(i=0; i<cnt; i++) {
char loader_name[256];
mtev_dso_loader_t *loader;
mtev_conf_section_t *include_sections = NULL;
int section_cnt;
if(!mtev_conf_get_stringbuf(sections[i], "ancestor-or-self::node()/@name",
loader_name, sizeof(loader_name))) {
mtevL(mtev_stderr, "No name defined in loader stanza %d\n", i+1);
continue;
}
if(mtev_conf_env_off(sections[i], NULL)) {
mtevL(mtev_debug, "loader %s environmentally disabled.\n", loader_name);
continue;
}
loader = (mtev_dso_loader_t *)
mtev_load_loader_image(&__mtev_image_loader, loader_name,
sections[i]);
if(!loader) {
mtevL(mtev_stderr, "Failed to load loader %s\n", loader_name);
mtev_dso_load_failure_count++;
continue;
}
if(loader->config) {
int rv;
mtev_hash_table *config;
include_sections = mtev_conf_get_sections(sections[i], "include", §ion_cnt);
if ((include_sections) && (section_cnt == 1)) {
config = mtev_conf_get_hash(*include_sections, "config");
}
else {
config = mtev_conf_get_hash(sections[i], "config");
}
mtev_conf_release_sections(include_sections, section_cnt);
rv = loader->config(loader, config);
if(rv == 0) {
mtev_hash_destroy(config, free, free);
free(config);
}
else if(rv < 0) {
mtevL(mtev_stderr, "Failed to config loader %s\n", loader_name);
mtev_dso_load_failure_count++;
continue;
}
}
if(loader->init && loader->init(loader))
mtevL(mtev_stderr, "Failed to init loader %s\n", loader_name);
}
mtev_conf_release_sections(sections, cnt);
}
void noit_check_resolver_init() {
static int initialized = 0;
int32_t cnt;
mtev_conf_section_t *servers, *searchdomains;
eventer_t e;
DCLOCK();
if(initialized != 0) {
DCUNLOCK();
return;
}
if(dns_init(NULL, 0) < 0)
mtevL(noit_error, "dns initialization failed.\n");
dns_ctx = dns_new(NULL);
if(dns_init(dns_ctx, 0) != 0) {
mtevL(noit_error, "dns initialization failed.\n");
DCUNLOCK();
exit(-1);
}
/* Optional servers */
servers = mtev_conf_get_sections(MTEV_CONF_ROOT, "//resolver//server", &cnt);
if(cnt) {
int i;
char server[128];
dns_add_serv(dns_ctx, NULL); /* reset */
for(i=0;i<cnt;i++) {
if(mtev_conf_get_stringbuf(servers[i], "self::node()",
server, sizeof(server))) {
if(mtev_conf_env_off(servers[i], NULL)) {
mtevL(noit_error, "DNS server %s environmentally ignored.\n", server);
}
else if(dns_add_serv(dns_ctx, server) < 0) {
mtevL(noit_error, "Failed adding DNS server: %s\n", server);
}
}
}
}
mtev_conf_release_sections(servers, cnt);
searchdomains = mtev_conf_get_sections(MTEV_CONF_ROOT, "//resolver//search", &cnt);
if(cnt) {
int i;
char search[128];
dns_add_srch(dns_ctx, NULL); /* reset */
for(i=0;i<cnt;i++) {
if(mtev_conf_get_stringbuf(searchdomains[i], "self::node()",
search, sizeof(search))) {
if(mtev_conf_env_off(searchdomains[i], NULL)) {
mtevL(noit_error, "DNS search %s environmentally ignored.\n", search);
}
else if(dns_add_srch(dns_ctx, search) < 0) {
mtevL(noit_error, "Failed adding DNS search path: %s\n", search);
}
else if(dns_search_flag) dns_search_flag = 0; /* enable search */
}
}
}
mtev_conf_release_sections(searchdomains, cnt);
if(mtev_conf_get_int32(MTEV_CONF_ROOT, "//resolver/@ndots", &cnt))
dns_set_opt(dns_ctx, DNS_OPT_NDOTS, cnt);
if(mtev_conf_get_int32(MTEV_CONF_ROOT, "//resolver/@ntries", &cnt))
dns_set_opt(dns_ctx, DNS_OPT_NTRIES, cnt);
if(mtev_conf_get_int32(MTEV_CONF_ROOT, "//resolver/@timeout", &cnt))
dns_set_opt(dns_ctx, DNS_OPT_TIMEOUT, cnt);
if(dns_open(dns_ctx) < 0) {
mtevL(noit_error, "dns open failed.\n");
DCUNLOCK();
exit(-1);
}
eventer_name_callback("dns_cache_callback", dns_cache_callback);
dns_set_tmcbck(dns_ctx, dns_cache_utm_fn, dns_ctx);
e = eventer_alloc_fd(dns_cache_callback, dns_ctx, dns_sock(dns_ctx),
EVENTER_READ|EVENTER_EXCEPTION);
eventer_add(e);
mtev_skiplist *dc = mtev_skiplist_alloc();
mtev_skiplist_set_compare(dc, name_lookup, name_lookup_k);
mtev_skiplist_add_index(dc, refresh_idx, refresh_idx_k);
ck_pr_barrier();
nc_dns_cache = dc;
/* maybe load it from cache */
if(noit_resolver_cache_load_hook_exists()) {
struct timeval now;
char *key;
void *data;
int len;
mtev_gettimeofday(&now, NULL);
while(noit_resolver_cache_load_hook_invoke(&key, &data, &len) == MTEV_HOOK_CONTINUE) {
dns_cache_node *n;
n = calloc(1, sizeof(*n));
if(dns_cache_node_deserialize(n, data, len) >= 0) {
n->target = strdup(key);
/* if the TTL indicates that it will expire in less than 60 seconds
* (including stuff that should have already expired), then fudge
* the last_updated time to make it expire some random time within
* the next 60 seconds.
*/
if(n->last_needed > now.tv_sec || n->last_updated > now.tv_sec) {
dns_cache_node_free(n);
break; /* impossible */
}
n->last_needed = now.tv_sec;
if(n->last_updated + n->ttl < now.tv_sec + 60) {
int fudge = MIN(60, n->ttl) + 1;
n->last_updated = now.tv_sec - n->ttl + (lrand48() % fudge);
}
mtev_skiplist_insert(nc_dns_cache, n);
n = NULL;
}
else {
mtevL(noit_error, "Failed to deserialize resolver cache record.\n");
}
if(n) dns_cache_node_free(n);
if(key) free(key);
if(data) free(data);
}
}
noit_check_resolver_loop(NULL, 0, NULL, NULL);
register_console_dns_cache_commands();
mtev_hash_init(&etc_hosts_cache);
noit_check_etc_hosts_cache_refresh(NULL, 0, NULL, NULL);
initialized = 1;
DCUNLOCK();
}
