void noit_lua_init_dns() {
int i;
const struct dns_nameval *nv;
struct dns_ctx *pctx;
/* HASH the rr types */
for(i=0, nv = dns_type_index(i); nv->name; nv = dns_type_index(++i))
noit_hash_store(&dns_rtypes,
nv->name, strlen(nv->name),
(void *)nv);
/* HASH the class types */
for(i=0, nv = dns_class_index(i); nv->name; nv = dns_class_index(++i))
noit_hash_store(&dns_ctypes,
nv->name, strlen(nv->name),
(void *)nv);
eventer_name_callback("lua/dns_eventer", noit_lua_dns_eventer);
eventer_name_callback("lua/dns_timeouts", noit_lua_dns_timeouts);
if (dns_init(NULL, 0) < 0 || (pctx = dns_new(NULL)) == NULL) {
noitL(noit_error, "Unable to initialize dns subsystem\n");
}
else
dns_free(pctx);
}
static int dns_module_init(noit_module_t *self) {
const struct dns_nameval *nv;
struct dns_ctx *pctx;
int i;
pthread_mutex_init(&dns_ctx_store_lock, NULL);
pthread_mutex_init(&active_events_lock, NULL);
/* HASH the rr types */
for(i=0, nv = dns_type_index(i); nv->name; nv = dns_type_index(++i))
noit_hash_store(&dns_rtypes,
nv->name, strlen(nv->name),
(void *)nv);
/* HASH the class types */
for(i=0, nv = dns_class_index(i); nv->name; nv = dns_class_index(++i))
noit_hash_store(&dns_ctypes,
nv->name, strlen(nv->name),
(void *)nv);
noit_check_interpolate_register_oper_fn("inaddrarpa",
dns_interpolate_inaddr_arpa);
noit_check_interpolate_register_oper_fn("reverseip",
dns_interpolate_reverse_ip);
if (dns_init(NULL, 0) < 0 || (pctx = dns_new(NULL)) == NULL) {
noitL(nlerr, "Unable to initialize dns subsystem\n");
return -1;
}
dns_free(pctx);
if(dns_ctx_alloc(NULL, 0) == NULL) {
noitL(nlerr, "Error setting up default dns resolver context.\n");
return -1;
}
return 0;
}
static dns_ctx_handle_t *dns_ctx_alloc(const char *ns, int port) {
void *vh;
dns_ctx_handle_t *h = NULL;
pthread_mutex_lock(&dns_ctx_store_lock);
if(ns == NULL && default_ctx_handle != NULL) {
/* special case -- default context */
h = default_ctx_handle;
noit_atomic_inc32(&h->refcnt);
goto bail;
}
if(ns &&
noit_hash_retrieve(&dns_ctx_store, ns, strlen(ns), &vh)) {
h = (dns_ctx_handle_t *)vh;
noit_atomic_inc32(&h->refcnt);
}
else {
int failed = 0;
h = calloc(1, sizeof(*h));
h->ns = ns ? strdup(ns) : NULL;
h->ctx = dns_new(NULL);
if(dns_init(h->ctx, 0) != 0) failed++;
if(ns) {
if(dns_add_serv(h->ctx, NULL) < 0) failed++;
if(dns_add_serv(h->ctx, ns) < 0) failed++;
}
if(port && port != DNS_PORT) {
dns_set_opt(h->ctx, DNS_OPT_PORT, port);
}
if(dns_open(h->ctx) < 0) failed++;
if(failed) {
noitL(nlerr, "dns_open failed\n");
free(h->ns);
free(h);
h = NULL;
goto bail;
}
dns_set_tmcbck(h->ctx, eventer_dns_utm_fn, h);
h->e = eventer_alloc();
h->e->mask = EVENTER_READ | EVENTER_EXCEPTION;
h->e->closure = h;
h->e->callback = dns_eventer_callback;
h->e->fd = dns_sock(h->ctx);
eventer_add(h->e);
h->refcnt = 1;
if(!ns)
default_ctx_handle = h;
else
noit_hash_store(&dns_ctx_store, h->ns, strlen(h->ns), h);
}
bail:
pthread_mutex_unlock(&dns_ctx_store_lock);
return h;
}
static gboolean _master_loadTopology(Master* master) {
MAGIC_ASSERT(master);
ConfigurationTopologyElement* e = configuration_getTopologyElement(master->config);
gchar* temporaryFilename = utility_getNewTemporaryFilename("shadow-topology-XXXXXX.graphml.xml");
/* igraph wants a path to a graphml file, prefer a path over cdata */
if(e->path.isSet) {
/* now make the configured path exist, pointing to the new file */
gint result = symlink(e->path.string->str, temporaryFilename);
if(result < 0) {
warning("Unable to create symlink at %s pointing to %s; symlink() returned %i error %i: %s",
temporaryFilename, e->path.string->str,
result, errno, g_strerror(errno));
} else {
/* that better not be a dangling link */
g_assert(g_file_test(temporaryFilename, G_FILE_TEST_IS_SYMLINK) &&
g_file_test(temporaryFilename, G_FILE_TEST_IS_REGULAR));
message("new topology file '%s' now linked at '%s'",
e->path.string->str, temporaryFilename);
}
} else {
utility_assert(e->cdata.isSet);
GError* error = NULL;
/* copy the cdata to the new temporary filename */
if(!g_file_set_contents(temporaryFilename, e->cdata.string->str,
(gssize)e->cdata.string->len, &error)) {
error("unable to write cdata topology to '%s': %s", temporaryFilename, error->message);
return FALSE;
}
}
/* initialize global routing model */
master->topology = topology_new(temporaryFilename);
g_unlink(temporaryFilename);
if(!master->topology) {
critical("fatal error loading topology at path '%s', check your syntax and try again", temporaryFilename);
g_free(temporaryFilename);
return FALSE;
}
g_free(temporaryFilename);
/* initialize global DNS addressing */
master->dns = dns_new();
return TRUE;
}
static int dns_module_init(noit_module_t *self) {
const struct dns_nameval *nv;
struct dns_ctx *pctx;
int i;
const char *config_val;
dns_mod_config_t *conf;
conf = noit_module_get_userdata(self);
pthread_mutex_init(&dns_ctx_store_lock, NULL);
pthread_mutex_init(&active_events_lock, NULL);
conf->contexts = DEFAULT_MAX_CONTEXTS;
if(noit_hash_retr_str(conf->options,
"contexts", strlen("contexts"),
(const char**)&config_val)) {
conf->contexts = atoi(config_val);
if (conf->contexts <= 0)
conf->contexts = DEFAULT_MAX_CONTEXTS;
}
/* HASH the rr types */
for(i=0, nv = dns_type_index(i); nv->name; nv = dns_type_index(++i))
noit_hash_store(&dns_rtypes,
nv->name, strlen(nv->name),
(void *)nv);
/* HASH the class types */
for(i=0, nv = dns_class_index(i); nv->name; nv = dns_class_index(++i))
noit_hash_store(&dns_ctypes,
nv->name, strlen(nv->name),
(void *)nv);
noit_check_interpolate_register_oper_fn("inaddrarpa",
dns_interpolate_inaddr_arpa);
noit_check_interpolate_register_oper_fn("reverseip",
dns_interpolate_reverse_ip);
if (dns_init(NULL, 0) < 0 || (pctx = dns_new(NULL)) == NULL) {
noitL(nlerr, "Unable to initialize dns subsystem\n");
return -1;
}
dns_free(pctx);
if(dns_module_dns_ctx_alloc(self, NULL, 0) == NULL) {
noitL(nlerr, "Error setting up default dns resolver context.\n");
return -1;
}
register_console_dns_commands();
return 0;
}
Slave* slave_new(Master* master, Configuration* config, guint randomSeed) {
Slave* slave = g_new0(Slave, 1);
MAGIC_INIT(slave);
g_mutex_init(&(slave->lock));
g_mutex_init(&(slave->pluginInitLock));
slave->master = master;
slave->config = config;
slave->random = random_new(randomSeed);
slave->rawFrequencyKHz = utility_getRawCPUFrequency(CONFIG_CPU_MAX_FREQ_FILE);
if(slave->rawFrequencyKHz == 0) {
info("unable to read '%s' for copying", CONFIG_CPU_MAX_FREQ_FILE);
}
slave->hosts = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, NULL);
slave->programs = g_hash_table_new_full(g_int_hash, g_int_equal, NULL, (GDestroyNotify)program_free);
slave->dns = dns_new();
slave->nWorkers = (guint) configuration_getNWorkerThreads(config);
slave->mainThreadWorker = worker_new(slave);
slave->cwdPath = g_get_current_dir();
slave->dataPath = g_build_filename(slave->cwdPath, "shadow.data", NULL);
slave->hostsPath = g_build_filename(slave->dataPath, "hosts", NULL);
if(g_file_test(slave->dataPath, G_FILE_TEST_EXISTS)) {
gboolean success = utility_removeAll(slave->dataPath);
utility_assert(success);
}
gchar* templateDataPath = g_build_filename(slave->cwdPath, "shadow.data.template", NULL);
if(g_file_test(templateDataPath, G_FILE_TEST_EXISTS)) {
gboolean success = utility_copyAll(templateDataPath, slave->dataPath);
utility_assert(success);
}
g_free(templateDataPath);
return slave;
}
static int
Resolver_init(Resolver *self, PyObject *args) {
int r = 0, create_new = 0, do_open = 1;
if (!PyArg_ParseTuple(args, "|ii", &create_new, &do_open)) {
PyErr_SetString(PyExc_TypeError, "Resolver(create_new=False, do_open=True) wrong arguments. See help(Resolver) for details.");
return -1;
}
//FIXME
if (0 == do_open) {
PyErr_SetString(PyExc_NotImplementedError, "Resolver() do_open=False not yet implemented. Pass True for now. Sorry.");
return -1;
}
self->ctx = NULL;
if (1 == create_new) {
self->ctx = dns_new(NULL);
if (NULL == self->ctx) {
PyErr_SetString(PyExc_MemoryError, "Resolver() failed to create new udns context.");
return -1;
}
}
r = dns_init(self->ctx, 0);
if (r < 0) {
PyErr_SetString(PyExc_Exception, "Resolver() failed to init udns context.");
return -1;
}
if (1 == do_open) {
self->fd = dns_open(self->ctx);
if (self->fd < 0) {
PyErr_SetString(PyExc_IOError, "Resolver() failed to open udns socket.");
return -1;
}
}
return 0;
}
void noit_check_resolver_init() {
eventer_t e;
if(dns_init(NULL, 0) < 0)
noitL(noit_error, "dns initialization failed.\n");
dns_ctx = dns_new(NULL);
if(dns_init(dns_ctx, 0) != 0 ||
dns_open(dns_ctx) < 0) {
noitL(noit_error, "dns initialization failed.\n");
}
eventer_name_callback("dns_cache_callback", dns_cache_callback);
dns_set_tmcbck(dns_ctx, dns_cache_utm_fn, dns_ctx);
e = eventer_alloc();
e->mask = EVENTER_READ | EVENTER_EXCEPTION;
e->closure = dns_ctx;
e->callback = dns_cache_callback;
e->fd = dns_sock(dns_ctx);
eventer_add(e);
noit_skiplist_init(&nc_dns_cache);
noit_skiplist_set_compare(&nc_dns_cache, name_lookup, name_lookup_k);
noit_skiplist_add_index(&nc_dns_cache, refresh_idx, refresh_idx_k);
noit_check_resolver_loop(NULL, 0, NULL, NULL);
register_console_dns_cache_commands();
}
void noit_check_resolver_init() {
int cnt;
mtev_conf_section_t *servers, *searchdomains;
eventer_t e;
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");
exit(-1);
}
/* Optional servers */
servers = mtev_conf_get_sections(NULL, "//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(dns_add_serv(dns_ctx, server) < 0) {
mtevL(noit_error, "Failed adding DNS server: %s\n", server);
}
}
}
free(servers);
}
searchdomains = mtev_conf_get_sections(NULL, "//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(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 */
}
}
free(searchdomains);
}
if(mtev_conf_get_int(NULL, "//resolver/@ndots", &cnt))
dns_set_opt(dns_ctx, DNS_OPT_NDOTS, cnt);
if(mtev_conf_get_int(NULL, "//resolver/@ntries", &cnt))
dns_set_opt(dns_ctx, DNS_OPT_NTRIES, cnt);
if(mtev_conf_get_int(NULL, "//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");
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();
e->mask = EVENTER_READ | EVENTER_EXCEPTION;
e->closure = dns_ctx;
e->callback = dns_cache_callback;
e->fd = dns_sock(dns_ctx);
eventer_add(e);
mtev_skiplist_init(&nc_dns_cache);
mtev_skiplist_set_compare(&nc_dns_cache, name_lookup, name_lookup_k);
mtev_skiplist_add_index(&nc_dns_cache, refresh_idx, refresh_idx_k);
/* maybe load it from cache */
if(noit_resolver_cache_load_hook_exists()) {
struct timeval now;
char *key;
void *data;
int len;
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)
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);
}
DCLOCK();
mtev_skiplist_insert(&nc_dns_cache, n);
DCUNLOCK();
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);
}
static dns_ctx_handle_t *dns_module_dns_ctx_alloc(noit_module_t *self, const char *ns, int port) {
void *vh;
char *hk = NULL;
dns_mod_config_t *conf = noit_module_get_userdata(self);
int randkey = random() % conf->contexts;
dns_ctx_handle_t *h = NULL;
if(ns && *ns == '\0') ns = NULL;
pthread_mutex_lock(&dns_ctx_store_lock);
if(ns == NULL && default_ctx_handle != NULL) {
/* special case -- default context */
h = default_ctx_handle;
dns_module_dns_ctx_acquire(h);
goto bail;
}
if (ns != NULL) {
int len = snprintf(NULL, 0, "%s:%d:%d", ns, port, randkey);
hk = (char *)malloc(len+1);
snprintf(hk, len+1, "%s:%d:%d", ns, port, randkey);
}
if(ns &&
noit_hash_retrieve(&dns_ctx_store, hk, strlen(hk), &vh)) {
h = (dns_ctx_handle_t *)vh;
dns_module_dns_ctx_acquire(h);
free(hk);
}
else {
int failed = 0;
h = calloc(1, sizeof(*h));
h->ns = ns ? strdup(ns) : NULL;
h->ctx = dns_new(NULL);
if(dns_init(h->ctx, 0) != 0) {
noitL(nlerr, "dns_init failed\n");
failed++;
}
dns_set_dbgfn(h->ctx, dns_debug_wrap);
if(ns) {
if(dns_add_serv(h->ctx, NULL) < 0) {
noitL(nlerr, "dns_add_serv(NULL) failed\n");
failed++;
}
if(dns_add_serv(h->ctx, ns) < 0) {
noitL(nlerr, "dns_add_serv(%s) failed\n", ns);
failed++;
}
}
if(port && port != DNS_PORT) {
dns_set_opt(h->ctx, DNS_OPT_PORT, port);
}
if(dns_open(h->ctx) < 0) {
noitL(nlerr, "dns_open failed\n");
failed++;
}
if(failed) {
free(h->ns);
dns_free(h->ctx);
free(h);
free(hk);
h = NULL;
goto bail;
}
h->hkey = hk;
dns_set_tmcbck(h->ctx, dns_module_eventer_dns_utm_fn, h);
h->e = eventer_alloc();
h->e->mask = EVENTER_READ | EVENTER_EXCEPTION;
h->e->closure = h;
h->e->callback = dns_module_eventer_callback;
h->e->fd = dns_sock(h->ctx);
eventer_add(h->e);
h->refcnt = 1;
if(!ns)
default_ctx_handle = h;
else
noit_hash_store(&dns_ctx_store, h->hkey, strlen(h->hkey), h);
}
bail:
pthread_mutex_unlock(&dns_ctx_store_lock);
return h;
}
