/** * 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; }