/**
* Clean up ACL.
*
*/
void
acl_cleanup(acl_type* acl, allocator_type* allocator)
{
if (!acl || !allocator) {
return;
}
acl_cleanup(acl->next, allocator);
allocator_deallocate(allocator, (void*) acl->address);
allocator_deallocate(allocator, (void*) acl);
return;
}
/**
* Clean up NSEC3 parameters.
*
*/
void
nsec3params_cleanup(nsec3params_type* nsec3params)
{
signconf_type* sc = NULL;
if (!nsec3params) {
return;
}
sc = (signconf_type*) nsec3params->sc;
allocator_deallocate(sc->allocator, (void*) nsec3params->salt_data);
allocator_deallocate(sc->allocator, (void*) nsec3params);
return;
}
/**
* Cleanup dns handler.
*
*/
void
dnshandler_cleanup(dnshandler_type* dnshandler)
{
allocator_type* allocator = NULL;
if (!dnshandler) {
return;
}
allocator = dnshandler->allocator;
netio_cleanup(dnshandler->netio);
query_cleanup(dnshandler->query);
allocator_deallocate(allocator, (void*) dnshandler->socklist);
allocator_deallocate(allocator, (void*) dnshandler);
return;
}
/**
* Clean up listener.
*
*/
void
listener_cleanup(listener_type* listener)
{
uint16_t i = 0;
allocator_type* allocator = NULL;
if (!listener) {
return;
}
for (i=0; i < listener->count; i++) {
interface_cleanup(&listener->interfaces[i]);
}
allocator = listener->allocator;
allocator_deallocate(allocator, (void*) listener->interfaces);
allocator_deallocate(allocator, (void*) listener);
return;
}
/**
* Create new schedule.
*
*/
schedule_type*
schedule_create(allocator_type* allocator)
{
schedule_type* schedule;
if (!allocator) {
return NULL;
}
schedule = (schedule_type*) allocator_alloc(allocator,
sizeof(schedule_type));
if (!schedule) {
ods_log_error("[%s] unable to create schedule: allocator_alloc() "
"failed", schedule_str);
return NULL;
}
schedule->allocator = allocator;
schedule->loading = 0;
schedule->flushcount = 0;
schedule->tasks = ldns_rbtree_create(task_compare);
if (!schedule->tasks) {
ods_log_error("[%s] unable to create schedule: ldns_rbtree_create() "
"failed", schedule_str);
allocator_deallocate(allocator, (void*) schedule);
return NULL;
}
lock_basic_init(&schedule->schedule_lock);
return schedule;
}
void scratch_allocator_deallocate(struct cel_allocator *allocator,
void *p) {
struct cel_allocator_scratch *a = (struct cel_allocator_scratch *) allocator;
if (!p)
return;
if ((char *) p < a->begin || (char *) p >= a->end) {
allocator_deallocate(a->backing, p);
return;
}
// Mark this slot as free
struct Header *h = header(p);
CEL_ASSERT("scratch", (h->size & 0x80000000u) == 0);
h->size = h->size | 0x80000000u;
// Advance the free pointer past all free slots.
while (a->free != a->allocate) {
struct Header *h = (struct Header *) a->free;
if ((h->size & 0x80000000u) == 0)
break;
a->free += h->size & 0x7fffffffu;
if (a->free == a->end)
a->free = a->begin;
}
}
/**
* Create new NSEC3 parameters.
*
*/
nsec3params_type*
nsec3params_create(void* sc, uint8_t algo, uint8_t flags, uint16_t iter,
const char* salt)
{
nsec3params_type* nsec3params = NULL;
signconf_type* signconf = (signconf_type*) sc;
uint8_t salt_len; /* calculate salt len */
uint8_t* salt_data; /* calculate salt data */
if (!sc) {
return NULL;
}
nsec3params = (nsec3params_type*) allocator_alloc(signconf->allocator,
sizeof(nsec3params_type));
if (!nsec3params) {
ods_log_error("[%s] unable to create: allocator_alloc() failed",
nsec3_str);
return NULL;
}
nsec3params->sc = sc;
nsec3params->algorithm = algo;
nsec3params->flags = flags;
nsec3params->iterations = iter;
/* construct the salt from the string */
if (nsec3params_create_salt(salt, &salt_len, &salt_data) != 0) {
ods_log_error("[%s] unable to create: create salt failed", nsec3_str);
allocator_deallocate(signconf->allocator, (void*)nsec3params);
return NULL;
}
nsec3params->salt_len = salt_len;
nsec3params->salt_data = salt_data;
nsec3params->rr = NULL;
return nsec3params;
}
/**
* Clean up task.
*
*/
void
task_cleanup(task_type* task)
{
allocator_type* allocator;
if (!task) {
return;
}
allocator = task->allocator;
allocator_deallocate(allocator, (void*) task);
allocator_cleanup(allocator);
return;
}
/**
* Push an interface to the listener.
*
*/
interface_type*
listener_push(listener_type* listener, char* address, int family, char* port)
{
interface_type* ifs_old = NULL;
ods_log_assert(listener);
ods_log_assert(address);
ifs_old = listener->interfaces;
listener->interfaces = (interface_type*) allocator_alloc(
listener->allocator, (listener->count + 1) * sizeof(interface_type));
if (!listener->interfaces) {
ods_log_error("[%s] unable to add interface: allocator_alloc() failed",
listener_str);
exit(1);
}
if (ifs_old) {
memcpy(listener->interfaces, ifs_old,
(listener->count) * sizeof(interface_type));
}
allocator_deallocate(listener->allocator, (void*) ifs_old);
listener->count++;
listener->interfaces[listener->count -1].address =
allocator_strdup(listener->allocator, address);
listener->interfaces[listener->count -1].family = family;
if (port) {
listener->interfaces[listener->count -1].port =
allocator_strdup(listener->allocator, port);
} else{
listener->interfaces[listener->count -1].port = NULL;
}
memset(&listener->interfaces[listener->count -1].addr, 0,
sizeof(union acl_addr_storage));
if (listener->interfaces[listener->count -1].family == AF_INET6 &&
strlen(listener->interfaces[listener->count -1].address) > 0) {
if (inet_pton(listener->interfaces[listener->count -1].family,
listener->interfaces[listener->count -1].address,
&listener->interfaces[listener->count -1].addr.addr6) != 1) {
ods_log_error("[%s] bad ip address '%s'",
listener->interfaces[listener->count -1].address);
return NULL;
}
} else if (listener->interfaces[listener->count -1].family == AF_INET &&
strlen(listener->interfaces[listener->count -1].address) > 0) {
if (inet_pton(listener->interfaces[listener->count -1].family,
listener->interfaces[listener->count -1].address,
&listener->interfaces[listener->count -1].addr.addr) != 1) {
ods_log_error("[%s] bad ip address '%s'",
listener->interfaces[listener->count -1].address);
return NULL;
}
}
return &listener->interfaces[listener->count -1];
}
/**
* Clean up engine.
*
*/
void
engine_cleanup(engine_type* engine)
{
size_t i = 0;
allocator_type* allocator;
cond_basic_type signal_cond;
lock_basic_type signal_lock;
if (!engine) {
return;
}
allocator = engine->allocator;
signal_cond = engine->signal_cond;
signal_lock = engine->signal_lock;
if (engine->workers && engine->config) {
for (i=0; i < (size_t) engine->config->num_worker_threads; i++) {
worker_cleanup(engine->workers[i]);
}
allocator_deallocate(allocator, (void*) engine->workers);
}
#if HAVE_DRUDGERS
if (engine->drudgers && engine->config) {
for (i=0; i < (size_t) engine->config->num_signer_threads; i++) {
worker_cleanup(engine->drudgers[i]);
}
allocator_deallocate(allocator, (void*) engine->drudgers);
}
#endif
schedule_cleanup(engine->taskq);
fifoq_cleanup(engine->signq);
cmdhandler_cleanup(engine->cmdhandler);
engine_config_cleanup(engine->config);
allocator_deallocate(allocator, (void*) engine);
lock_basic_destroy(&signal_lock);
lock_basic_off(&signal_cond);
allocator_cleanup(allocator);
return;
}
/**
* Clean up zone.
*
*/
void
zone_cleanup(zone_type* zone)
{
allocator_type* allocator;
lock_basic_type zone_lock;
lock_basic_type xfr_lock;
if (!zone) {
return;
}
allocator = zone->allocator;
zone_lock = zone->zone_lock;
xfr_lock = zone->xfr_lock;
ldns_rdf_deep_free(zone->apex);
adapter_cleanup(zone->adinbound);
adapter_cleanup(zone->adoutbound);
namedb_cleanup(zone->db);
ixfr_cleanup(zone->ixfr);
xfrd_cleanup(zone->xfrd);
notify_cleanup(zone->notify);
signconf_cleanup(zone->signconf);
stats_cleanup(zone->stats);
allocator_deallocate(allocator, (void*) zone->notify_command);
allocator_deallocate(allocator, (void*) zone->notify_args);
allocator_deallocate(allocator, (void*) zone->policy_name);
allocator_deallocate(allocator, (void*) zone->signconf_filename);
allocator_deallocate(allocator, (void*) zone->name);
allocator_deallocate(allocator, (void*) zone);
allocator_cleanup(allocator);
lock_basic_destroy(&xfr_lock);
lock_basic_destroy(&zone_lock);
return;
}
/**
* Clean up duration.
*
*/
void
duration_cleanup(duration_type* duration)
{
allocator_type* allocator;
if (!duration) {
return;
}
allocator = duration->allocator;
allocator_deallocate(allocator, (void*) duration);
allocator_cleanup(allocator);
return;
}
/**
* Cleanup query.
*
*/
void
query_cleanup(query_type* q)
{
allocator_type* allocator = NULL;
if (!q) {
return;
}
allocator = q->allocator;
buffer_cleanup(q->buffer, allocator);
tsig_rr_cleanup(q->tsig_rr);
allocator_deallocate(allocator, (void*)q);
allocator_cleanup(allocator);
return;
}
/**
* Clean up DNS input adapter.
*
*/
void
dnsin_cleanup(dnsin_type* addns)
{
allocator_type* allocator = NULL;
if (!addns) {
return;
}
allocator = addns->allocator;
acl_cleanup(addns->request_xfr, allocator);
acl_cleanup(addns->allow_notify, allocator);
tsig_cleanup(addns->tsig, allocator);
allocator_deallocate(allocator, (void*) addns);
allocator_cleanup(allocator);
return;
}
/**
* Clean up DNS output adapter.
*
*/
void
dnsout_cleanup(dnsout_type* addns)
{
allocator_type* allocator = NULL;
if (!addns) {
return;
}
allocator = addns->allocator;
acl_cleanup(addns->provide_xfr, allocator);
acl_cleanup(addns->do_notify, allocator);
tsig_cleanup(addns->tsig, allocator);
allocator_deallocate(allocator, (void*) addns);
allocator_cleanup(allocator);
return;
}
/**
* Clean up worker.
*
*/
void
worker_cleanup(worker_type* worker)
{
allocator_type* allocator;
cond_basic_type worker_cond;
lock_basic_type worker_lock;
if (!worker) {
return;
}
allocator = worker->allocator;
worker_cond = worker->worker_alarm;
worker_lock = worker->worker_lock;
allocator_deallocate(allocator, (void*) worker);
lock_basic_destroy(&worker_lock);
lock_basic_off(&worker_cond);
return;
}
/**
* Free zonelist.
*
*/
void
zonelist_free(zonelist_type* zl)
{
allocator_type* allocator;
lock_basic_type zl_lock;
if (!zl) {
return;
}
if (zl->zones) {
node_delfunc(zl->zones->root);
ldns_rbtree_free(zl->zones);
zl->zones = NULL;
}
allocator = zl->allocator;
zl_lock = zl->zl_lock;
allocator_deallocate(allocator, (void*) zl);
lock_basic_destroy(&zl_lock);
return;
}
/**
* Main. start interface tool.
*
*/
int
main(int argc, char* argv[])
{
char* cmd = NULL;
int ret = 0;
allocator_type* clialloc = allocator_create(malloc, free);
if (!clialloc) {
fprintf(stderr,"error, malloc failed for client\n");
exit(1);
}
/* argv[0] is always the executable name so
argc is always 1 or higher */
ods_log_assert(argc >= 1);
/* concat arguments an add 1 extra char for
adding '\n' char later on, but only when argc > 1 */
cmd = ods_str_join(clialloc,argc-1,&argv[1],' ');
if (argc > 1 && !cmd) {
fprintf(stderr, "memory allocation failed\n");
exit(1);
}
/* main stuff */
if (!cmd) {
ret = interface_start(cmd);
} else {
if (ods_strcmp(cmd, "-h") == 0 || ods_strcmp(cmd, "--help") == 0) {
usage(stdout);
ret = 1;
} else {
strcat(cmd,"\n");
ret = interface_start(cmd);
}
}
/* done */
allocator_deallocate(clialloc, (void*) cmd);
allocator_cleanup(clialloc);
return ret;
}
/**
* Clean up a zonelist.
*
*/
void
zonelist_cleanup(zonelist_type* zl)
{
allocator_type* allocator;
lock_basic_type zl_lock;
if (!zl) {
return;
}
ods_log_debug("[%s] cleanup zonelist", zl_str);
if (zl->zones) {
zone_delfunc(zl->zones->root);
ldns_rbtree_free(zl->zones);
zl->zones = NULL;
}
allocator = zl->allocator;
zl_lock = zl->zl_lock;
allocator_deallocate(allocator, (void*) zl);
lock_basic_destroy(&zl_lock);
return;
}
/**
* Cleanup notify structure.
*
*/
void
notify_cleanup(notify_type* notify)
{
allocator_type* allocator = NULL;
if (!notify) {
return;
}
allocator = notify->allocator;
if (notify->handler.fd != -1) {
close(notify->handler.fd);
notify->handler.fd = -1;
}
if (notify->soa) {
ldns_rr_free(notify->soa);
}
tsig_rr_cleanup(notify->tsig_rr);
allocator_deallocate(allocator, (void*) notify);
allocator_cleanup(allocator);
return;
}
/**
* Clean up queue.
*
*/
void
fifoq_cleanup(fifoq_type* q)
{
allocator_type* allocator;
lock_basic_type q_lock;
cond_basic_type q_threshold;
cond_basic_type q_nonfull;
if (!q) {
return;
}
allocator = q->allocator;
q_lock = q->q_lock;
q_threshold = q->q_threshold;
q_nonfull = q->q_nonfull;
allocator_deallocate(allocator, (void*) q);
lock_basic_off(&q_threshold);
lock_basic_off(&q_nonfull);
lock_basic_destroy(&q_lock);
return;
}
/**
* Create a new zone list.
*
*/
zonelist_type*
zonelist_create(allocator_type* allocator)
{
zonelist_type* zlist = NULL;
if (allocator) {
zlist = (zonelist_type*) allocator_alloc(allocator, sizeof(zonelist_type));
}
if (!zlist) {
ods_log_error("[%s] unable to create zonelist: allocator_alloc() "
"failed", zl_str);
return NULL;
}
zlist->allocator = allocator;
zlist->zones = ldns_rbtree_create(zone_compare);
if (!zlist->zones) {
ods_log_error("[%s] unable to create zonelist: ldns_rbtree_create() "
"failed", zl_str);
allocator_deallocate(allocator, (void*) zlist);
return NULL;
}
zlist->last_modified = 0;
lock_basic_init(&zlist->zl_lock);
return zlist;
}
/**
* Start dns handler.
*
*/
void
dnshandler_start(dnshandler_type* dnshandler)
{
size_t i = 0;
engine_type* engine = NULL;
netio_handler_type* tcp_accept_handlers = NULL;
ods_log_assert(dnshandler);
ods_log_assert(dnshandler->engine);
ods_log_debug("[%s] start", dnsh_str);
/* udp */
for (i=0; i < dnshandler->interfaces->count; i++) {
struct udp_data* data = NULL;
netio_handler_type* handler = NULL;
data = (struct udp_data*) allocator_alloc(dnshandler->allocator,
sizeof(struct udp_data));
if (!data) {
ods_log_error("[%s] unable to start: allocator_alloc() "
"failed", dnsh_str);
dnshandler->thread_id = 0;
engine->need_to_exit = 1;
break;
}
data->query = dnshandler->query;
data->engine = dnshandler->engine;
data->socket = &dnshandler->socklist->udp[i];
handler = (netio_handler_type*) allocator_alloc(
dnshandler->allocator, sizeof(netio_handler_type));
if (!handler) {
ods_log_error("[%s] unable to start: allocator_alloc() "
"failed", dnsh_str);
allocator_deallocate(dnshandler->allocator, (void*)data);
dnshandler->thread_id = 0;
engine->need_to_exit = 1;
break;
}
handler->fd = dnshandler->socklist->udp[i].s;
handler->timeout = NULL;
handler->user_data = data;
handler->event_types = NETIO_EVENT_READ;
handler->event_handler = sock_handle_udp;
ods_log_debug("[%s] add udp network handler fd %u", dnsh_str,
(unsigned) handler->fd);
netio_add_handler(dnshandler->netio, handler);
}
/* tcp */
tcp_accept_handlers = (netio_handler_type*) allocator_alloc(
dnshandler->allocator,
dnshandler->interfaces->count * sizeof(netio_handler_type));
for (i=0; i < dnshandler->interfaces->count; i++) {
struct tcp_accept_data* data = NULL;
netio_handler_type* handler = NULL;
data = (struct tcp_accept_data*) allocator_alloc(
dnshandler->allocator, sizeof(struct tcp_accept_data));
if (!data) {
ods_log_error("[%s] unable to start: allocator_alloc() "
"failed", dnsh_str);
dnshandler->thread_id = 0;
engine->need_to_exit = 1;
return;
}
data->engine = dnshandler->engine;
data->socket = &dnshandler->socklist->udp[i];
data->tcp_accept_handler_count = dnshandler->interfaces->count;
data->tcp_accept_handlers = tcp_accept_handlers;
handler = &tcp_accept_handlers[i];
handler->fd = dnshandler->socklist->tcp[i].s;
handler->timeout = NULL;
handler->user_data = data;
handler->event_types = NETIO_EVENT_READ;
handler->event_handler = sock_handle_tcp_accept;
ods_log_debug("[%s] add tcp network handler fd %u", dnsh_str,
(unsigned) handler->fd);
netio_add_handler(dnshandler->netio, handler);
}
/* service */
while (dnshandler->need_to_exit == 0) {
ods_log_deeebug("[%s] netio dispatch", dnsh_str);
if (netio_dispatch(dnshandler->netio, NULL, NULL) == -1) {
if (errno != EINTR) {
ods_log_error("[%s] unable to dispatch netio: %s", dnsh_str,
strerror(errno));
break;
}
}
}
/* shutdown */
ods_log_debug("[%s] shutdown", dnsh_str);
for (i=0; i < dnshandler->interfaces->count; i++) {
if (dnshandler->socklist->udp[i].s != -1) {
close(dnshandler->socklist->udp[i].s);
freeaddrinfo((void*)dnshandler->socklist->udp[i].addr);
}
if (dnshandler->socklist->tcp[i].s != -1) {
close(dnshandler->socklist->tcp[i].s);
freeaddrinfo((void*)dnshandler->socklist->tcp[i].addr);
}
}
return;
}
void scratch_allocator_destroy(struct cel_allocator *a) {
struct cel_allocator_scratch *m = (struct cel_allocator_scratch *) a;
allocator_deallocate(m->backing, m->begin);
}
/**
* Clean up config.
*
*/
void
engine_config_cleanup(engineconfig_type* config)
{
allocator_type* allocator;
if (!config) {
return;
}
allocator = config->allocator;
allocator_deallocate(allocator, (void*) config->cfg_filename);
allocator_deallocate(allocator, (void*) config->policy_filename);
allocator_deallocate(allocator, (void*) config->zonelist_filename);
allocator_deallocate(allocator, (void*) config->zonefetch_filename);
allocator_deallocate(allocator, (void*) config->log_filename);
allocator_deallocate(allocator, (void*) config->pid_filename);
allocator_deallocate(allocator, (void*) config->delegation_signer_submit_command);
allocator_deallocate(allocator, (void*) config->delegation_signer_retract_command);
allocator_deallocate(allocator, (void*) config->clisock_filename);
allocator_deallocate(allocator, (void*) config->working_dir);
allocator_deallocate(allocator, (void*) config->username);
allocator_deallocate(allocator, (void*) config->group);
allocator_deallocate(allocator, (void*) config->chroot);
allocator_deallocate(allocator, (void*) config->datastore);
allocator_deallocate(allocator, (void*) config->db_host);
allocator_deallocate(allocator, (void*) config->db_username);
allocator_deallocate(allocator, (void*) config->db_password);
allocator_deallocate(allocator, (void*) config);
return;
}
