static void
initialize(void) {
char *pk11_provider;
RUNTIME_CHECK(isc_mutex_init(&alloclock) == ISC_R_SUCCESS);
RUNTIME_CHECK(isc_mutex_init(&sessionlock) == ISC_R_SUCCESS);
pk11_provider = getenv("PKCS11_PROVIDER");
if (pk11_provider != NULL)
lib_name = pk11_provider;
}
isc_result_t
isc_quota_init(isc_quota_t *quota, int max) {
quota->max = max;
quota->used = 0;
quota->soft = 0;
return (isc_mutex_init("a->lock));
}
isc_result_t
dns_portlist_create(isc_mem_t *mctx, dns_portlist_t **portlistp) {
dns_portlist_t *portlist;
isc_result_t result;
REQUIRE(portlistp != NULL && *portlistp == NULL);
portlist = isc_mem_get(mctx, sizeof(*portlist));
if (portlist == NULL)
return (ISC_R_NOMEMORY);
result = isc_mutex_init(&portlist->lock);
if (result != ISC_R_SUCCESS) {
isc_mem_put(mctx, portlist, sizeof(*portlist));
return (result);
}
result = isc_refcount_init(&portlist->refcount, 1);
if (result != ISC_R_SUCCESS) {
DESTROYLOCK(&portlist->lock);
isc_mem_put(mctx, portlist, sizeof(*portlist));
return (result);
}
portlist->list = NULL;
portlist->allocated = 0;
portlist->active = 0;
portlist->mctx = NULL;
isc_mem_attach(mctx, &portlist->mctx);
portlist->magic = DNS_PORTLIST_MAGIC;
*portlistp = portlist;
return (ISC_R_SUCCESS);
}
isc_result_t
ns_lwsearchlist_create(isc_mem_t *mctx, ns_lwsearchlist_t **listp) {
ns_lwsearchlist_t *list;
isc_result_t result;
REQUIRE(mctx != NULL);
REQUIRE(listp != NULL && *listp == NULL);
list = isc_mem_get(mctx, sizeof(ns_lwsearchlist_t));
if (list == NULL)
return (ISC_R_NOMEMORY);
result = isc_mutex_init(&list->lock);
if (result != ISC_R_SUCCESS) {
isc_mem_put(mctx, list, sizeof(ns_lwsearchlist_t));
return (result);
}
list->mctx = NULL;
isc_mem_attach(mctx, &list->mctx);
list->refs = 1;
ISC_LIST_INIT(list->names);
list->magic = LWSEARCHLIST_MAGIC;
*listp = list;
return (ISC_R_SUCCESS);
}
isc_result_t
isc__app_ctxstart(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
isc_result_t result;
REQUIRE(VALID_APPCTX(ctx));
/*
* Start an ISC library application.
*/
main_thread = GetCurrentThread();
result = isc_mutex_init(&ctx->lock);
if (result != ISC_R_SUCCESS)
return (result);
ctx->shutdown_requested = ISC_FALSE;
ctx->running = ISC_FALSE;
ctx->want_shutdown = ISC_FALSE;
ctx->want_reload = ISC_FALSE;
ctx->blocked = ISC_FALSE;
/* Create the reload event in a non-signaled state */
ctx->hEvents[RELOAD_EVENT] = CreateEvent(NULL, FALSE, FALSE, NULL);
/* Create the shutdown event in a non-signaled state */
ctx->hEvents[SHUTDOWN_EVENT] = CreateEvent(NULL, FALSE, FALSE, NULL);
ISC_LIST_INIT(ctx->on_run);
return (ISC_R_SUCCESS);
}
isc_result_t
ldapdb_create(isc_mem_t *mctx, dns_name_t *name, dns_dbtype_t type,
dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
void *driverarg, dns_db_t **dbp)
{
ldapdb_t *ldapdb = NULL;
isc_result_t result;
isc_boolean_t lock_ready = ISC_FALSE;
UNUSED(driverarg); /* Currently we don't need any data */
/* Database instance name. */
REQUIRE(argc == LDAP_DB_ARGC);
REQUIRE(type == LDAP_DB_TYPE);
REQUIRE(rdclass == LDAP_DB_RDATACLASS);
REQUIRE(dbp != NULL && *dbp == NULL);
CHECKED_MEM_GET_PTR(mctx, ldapdb);
ZERO_PTR(ldapdb);
isc_mem_attach(mctx, &ldapdb->common.mctx);
CHECK(isc_mutex_init(&ldapdb->newversion_lock));
lock_ready = ISC_TRUE;
dns_name_init(&ldapdb->common.origin, NULL);
isc_ondestroy_init(&ldapdb->common.ondest);
ldapdb->common.magic = DNS_DB_MAGIC;
ldapdb->common.impmagic = LDAPDB_MAGIC;
ldapdb->common.methods = &ldapdb_methods;
ldapdb->common.attributes = 0;
ldapdb->common.rdclass = rdclass;
CHECK(dns_name_dupwithoffsets(name, mctx, &ldapdb->common.origin));
CHECK(isc_refcount_init(&ldapdb->refs, 1));
CHECK(manager_get_ldap_instance(argv[0], &ldapdb->ldap_inst));
CHECK(dns_db_create(mctx, "rbt", name, dns_dbtype_zone,
dns_rdataclass_in, 0, NULL, &ldapdb->rbtdb));
*dbp = (dns_db_t *)ldapdb;
return ISC_R_SUCCESS;
cleanup:
if (ldapdb != NULL) {
if (lock_ready == ISC_TRUE)
RUNTIME_CHECK(isc_mutex_destroy(&ldapdb->newversion_lock)
== ISC_R_SUCCESS);
if (dns_name_dynamic(&ldapdb->common.origin))
dns_name_free(&ldapdb->common.origin, mctx);
isc_mem_putanddetach(&ldapdb->common.mctx, ldapdb,
sizeof(*ldapdb));
}
return result;
}
isc_result_t
isc_task_create(isc_taskmgr_t *manager, unsigned int quantum,
isc_task_t **taskp)
{
isc_task_t *task;
isc_boolean_t exiting;
REQUIRE(VALID_MANAGER(manager));
REQUIRE(taskp != NULL && *taskp == NULL);
task = isc_mem_get(manager->mctx, sizeof(*task));
if (task == NULL)
return (ISC_R_NOMEMORY);
XTRACE("isc_task_create");
task->manager = manager;
if (isc_mutex_init(&task->lock) != ISC_R_SUCCESS) {
isc_mem_put(manager->mctx, task, sizeof(*task));
UNEXPECTED_ERROR(__FILE__, __LINE__,
"isc_mutex_init() %s",
isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
ISC_MSG_FAILED, "failed"));
return (ISC_R_UNEXPECTED);
}
task->state = task_state_idle;
task->references = 1;
INIT_LIST(task->events);
INIT_LIST(task->on_shutdown);
task->quantum = quantum;
task->flags = 0;
task->now = 0;
#ifdef ISC_TASK_NAMES
memset(task->name, 0, sizeof(task->name));
task->tag = NULL;
#endif
INIT_LINK(task, link);
INIT_LINK(task, ready_link);
exiting = ISC_FALSE;
LOCK(&manager->lock);
if (!manager->exiting) {
if (task->quantum == 0)
task->quantum = manager->default_quantum;
APPEND(manager->tasks, task, link);
} else
exiting = ISC_TRUE;
UNLOCK(&manager->lock);
if (exiting) {
DESTROYLOCK(&task->lock);
isc_mem_put(manager->mctx, task, sizeof(*task));
return (ISC_R_SHUTTINGDOWN);
}
task->magic = TASK_MAGIC;
*taskp = task;
return (ISC_R_SUCCESS);
}
ISC_TASKFUNC_SCOPE isc_result_t
isc__task_create(isc_taskmgr_t *manager0, unsigned int quantum,
isc_task_t **taskp)
{
isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
isc__task_t *task;
isc_boolean_t exiting;
isc_result_t result;
REQUIRE(VALID_MANAGER(manager));
REQUIRE(taskp != NULL && *taskp == NULL);
task = isc_mem_get(manager->mctx, sizeof(*task));
if (task == NULL)
return (ISC_R_NOMEMORY);
XTRACE("isc_task_create");
task->manager = manager;
result = isc_mutex_init(&task->lock);
if (result != ISC_R_SUCCESS) {
isc_mem_put(manager->mctx, task, sizeof(*task));
return (result);
}
task->state = task_state_idle;
task->references = 1;
INIT_LIST(task->events);
INIT_LIST(task->on_shutdown);
task->quantum = quantum;
task->flags = 0;
task->now = 0;
memset(task->name, 0, sizeof(task->name));
task->tag = NULL;
INIT_LINK(task, link);
INIT_LINK(task, ready_link);
INIT_LINK(task, ready_priority_link);
exiting = ISC_FALSE;
LOCK(&manager->lock);
if (!manager->exiting) {
if (task->quantum == 0)
task->quantum = manager->default_quantum;
APPEND(manager->tasks, task, link);
} else
exiting = ISC_TRUE;
UNLOCK(&manager->lock);
if (exiting) {
DESTROYLOCK(&task->lock);
isc_mem_put(manager->mctx, task, sizeof(*task));
return (ISC_R_SHUTTINGDOWN);
}
task->common.methods = (isc_taskmethods_t *)&taskmethods;
task->common.magic = ISCAPI_TASK_MAGIC;
task->common.impmagic = TASK_MAGIC;
*taskp = (isc_task_t *)task;
return (ISC_R_SUCCESS);
}
isc_result_t
ns_interfacemgr_create(isc_mem_t *mctx, isc_taskmgr_t *taskmgr,
isc_socketmgr_t *socketmgr,
dns_dispatchmgr_t *dispatchmgr,
ns_interfacemgr_t **mgrp)
{
isc_result_t result;
ns_interfacemgr_t *mgr;
REQUIRE(mctx != NULL);
REQUIRE(mgrp != NULL);
REQUIRE(*mgrp == NULL);
mgr = isc_mem_get(mctx, sizeof(*mgr));
if (mgr == NULL)
return (ISC_R_NOMEMORY);
mgr->mctx = NULL;
isc_mem_attach(mctx, &mgr->mctx);
result = isc_mutex_init(&mgr->lock);
if (result != ISC_R_SUCCESS)
goto cleanup_mem;
mgr->taskmgr = taskmgr;
mgr->socketmgr = socketmgr;
mgr->dispatchmgr = dispatchmgr;
mgr->generation = 1;
mgr->listenon4 = NULL;
mgr->listenon6 = NULL;
ISC_LIST_INIT(mgr->interfaces);
ISC_LIST_INIT(mgr->listenon);
/*
* The listen-on lists are initially empty.
*/
result = ns_listenlist_create(mctx, &mgr->listenon4);
if (result != ISC_R_SUCCESS)
goto cleanup_mem;
ns_listenlist_attach(mgr->listenon4, &mgr->listenon6);
result = dns_aclenv_init(mctx, &mgr->aclenv);
if (result != ISC_R_SUCCESS)
goto cleanup_listenon;
mgr->references = 1;
mgr->magic = IFMGR_MAGIC;
*mgrp = mgr;
return (ISC_R_SUCCESS);
cleanup_listenon:
ns_listenlist_detach(&mgr->listenon4);
ns_listenlist_detach(&mgr->listenon6);
cleanup_mem:
isc_mem_putanddetach(&mgr->mctx, mgr, sizeof(*mgr));
return (result);
}
static isc_result_t
findnode(dns_db_t *db, dns_name_t *name, isc_boolean_t create,
dns_dbnode_t **nodep)
{
dns_ecdb_t *ecdb = (dns_ecdb_t *)db;
isc_mem_t *mctx;
dns_ecdbnode_t *node;
isc_result_t result;
REQUIRE(VALID_ECDB(ecdb));
REQUIRE(nodep != NULL && *nodep == NULL);
UNUSED(name);
if (create != ISC_TRUE) {
/* an 'ephemeral' node is never reused. */
return (ISC_R_NOTFOUND);
}
mctx = ecdb->common.mctx;
node = isc_mem_get(mctx, sizeof(*node));
if (node == NULL)
return (ISC_R_NOMEMORY);
result = isc_mutex_init(&node->lock);
if (result != ISC_R_SUCCESS) {
UNEXPECTED_ERROR(__FILE__, __LINE__,
"isc_mutex_init() failed: %s",
isc_result_totext(result));
isc_mem_put(mctx, node, sizeof(*node));
return (ISC_R_UNEXPECTED);
}
dns_name_init(&node->name, NULL);
result = dns_name_dup(name, mctx, &node->name);
if (result != ISC_R_SUCCESS) {
DESTROYLOCK(&node->lock);
isc_mem_put(mctx, node, sizeof(*node));
return (result);
}
node->ecdb= ecdb;
node->references = 1;
ISC_LIST_INIT(node->rdatasets);
ISC_LINK_INIT(node, link);
LOCK(&ecdb->lock);
ISC_LIST_APPEND(ecdb->nodes, node, link);
UNLOCK(&ecdb->lock);
node->magic = ECDBNODE_MAGIC;
*nodep = node;
return (ISC_R_SUCCESS);
}
static isc_result_t
dns_ecdb_create(isc_mem_t *mctx, dns_name_t *origin, dns_dbtype_t type,
dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
void *driverarg, dns_db_t **dbp)
{
dns_ecdb_t *ecdb;
isc_result_t result;
REQUIRE(mctx != NULL);
REQUIRE(origin == dns_rootname);
REQUIRE(type == dns_dbtype_cache);
REQUIRE(dbp != NULL && *dbp == NULL);
UNUSED(argc);
UNUSED(argv);
UNUSED(driverarg);
ecdb = isc_mem_get(mctx, sizeof(*ecdb));
if (ecdb == NULL)
return (ISC_R_NOMEMORY);
ecdb->common.attributes = DNS_DBATTR_CACHE;
ecdb->common.rdclass = rdclass;
ecdb->common.methods = &ecdb_methods;
dns_name_init(&ecdb->common.origin, NULL);
result = dns_name_dupwithoffsets(origin, mctx, &ecdb->common.origin);
if (result != ISC_R_SUCCESS) {
isc_mem_put(mctx, ecdb, sizeof(*ecdb));
return (result);
}
result = isc_mutex_init(&ecdb->lock);
if (result != ISC_R_SUCCESS) {
UNEXPECTED_ERROR(__FILE__, __LINE__,
"isc_mutex_init() failed: %s",
isc_result_totext(result));
if (dns_name_dynamic(&ecdb->common.origin))
dns_name_free(&ecdb->common.origin, mctx);
isc_mem_put(mctx, ecdb, sizeof(*ecdb));
return (ISC_R_UNEXPECTED);
}
ecdb->references = 1;
ISC_LIST_INIT(ecdb->nodes);
ecdb->common.mctx = NULL;
isc_mem_attach(mctx, &ecdb->common.mctx);
ecdb->common.impmagic = ECDB_MAGIC;
ecdb->common.magic = DNS_DB_MAGIC;
*dbp = (dns_db_t *)ecdb;
return (ISC_R_SUCCESS);
}
isc_result_t
isc_refcount_init(isc_refcount_t *ref, unsigned int n) {
REQUIRE(ref != NULL);
ref->refs = n;
#if defined(ISC_PLATFORM_USETHREADS) && !defined(ISC_PLATFORM_HAVEXADD)
return (isc_mutex_init(&ref->lock));
#else
return (ISC_R_SUCCESS);
#endif
}
ATF_TC_BODY(all_events, tc) {
isc_result_t result;
isc_task_t *task = NULL;
isc_event_t *event;
int a = 0, b = 0;
int i = 0;
UNUSED(tc);
counter = 1;
result = isc_mutex_init(&set_lock);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
result = isc_test_begin(NULL, ISC_TRUE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
result = isc_task_create(taskmgr, 0, &task);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
/* First event */
event = isc_event_allocate(mctx, task, ISC_TASKEVENT_TEST,
set, &a, sizeof (isc_event_t));
ATF_REQUIRE(event != NULL);
ATF_CHECK_EQ(a, 0);
isc_task_send(task, &event);
event = isc_event_allocate(mctx, task, ISC_TASKEVENT_TEST,
set, &b, sizeof (isc_event_t));
ATF_REQUIRE(event != NULL);
ATF_CHECK_EQ(b, 0);
isc_task_send(task, &event);
while ((a == 0 || b == 0) && i++ < 5000) {
#ifndef ISC_PLATFORM_USETHREADS
while (isc__taskmgr_ready(taskmgr))
isc__taskmgr_dispatch(taskmgr);
#endif
isc_test_nap(1000);
}
ATF_CHECK(a != 0);
ATF_CHECK(b != 0);
isc_task_destroy(&task);
ATF_REQUIRE_EQ(task, NULL);
isc_test_end();
}
isc_result_t
isc_ratelimiter_create(isc_mem_t *mctx, isc_timermgr_t *timermgr,
isc_task_t *task, isc_ratelimiter_t **ratelimiterp)
{
isc_result_t result;
isc_ratelimiter_t *rl;
INSIST(ratelimiterp != NULL && *ratelimiterp == NULL);
rl = isc_mem_get(mctx, sizeof(*rl));
if (rl == NULL)
return ISC_R_NOMEMORY;
rl->mctx = mctx;
rl->refs = 1;
rl->task = task;
isc_interval_set(&rl->interval, 0, 0);
rl->timer = NULL;
rl->pertic = 1;
rl->state = isc_ratelimiter_idle;
ISC_LIST_INIT(rl->pending);
result = isc_mutex_init(&rl->lock);
if (result != ISC_R_SUCCESS)
goto free_mem;
result = isc_timer_create(timermgr, isc_timertype_inactive,
NULL, NULL, rl->task, ratelimiter_tick,
rl, &rl->timer);
if (result != ISC_R_SUCCESS)
goto free_mutex;
/*
* Increment the reference count to indicate that we may
* (soon) have events outstanding.
*/
rl->refs++;
ISC_EVENT_INIT(&rl->shutdownevent,
sizeof(isc_event_t),
0, NULL, ISC_RATELIMITEREVENT_SHUTDOWN,
ratelimiter_shutdowncomplete, rl, rl, NULL, NULL);
*ratelimiterp = rl;
return (ISC_R_SUCCESS);
free_mutex:
DESTROYLOCK(&rl->lock);
free_mem:
isc_mem_put(mctx, rl, sizeof(*rl));
return (result);
}
isc_result_t
dns_dbtable_create(isc_mem_t *mctx, dns_rdataclass_t rdclass,
dns_dbtable_t **dbtablep)
{
dns_dbtable_t *dbtable;
isc_result_t result;
REQUIRE(mctx != NULL);
REQUIRE(dbtablep != NULL && *dbtablep == NULL);
dbtable = (dns_dbtable_t *)isc_mem_get(mctx, sizeof(*dbtable));
if (dbtable == NULL)
return (ISC_R_NOMEMORY);
dbtable->rbt = NULL;
result = dns_rbt_create(mctx, dbdetach, NULL, &dbtable->rbt);
if (result != ISC_R_SUCCESS)
goto clean1;
result = isc_mutex_init(&dbtable->lock);
if (result != ISC_R_SUCCESS)
goto clean2;
result = isc_rwlock_init(&dbtable->tree_lock, 0, 0);
if (result != ISC_R_SUCCESS)
goto clean3;
dbtable->default_db = NULL;
dbtable->mctx = NULL;
isc_mem_attach(mctx, &dbtable->mctx);
dbtable->rdclass = rdclass;
dbtable->magic = DBTABLE_MAGIC;
dbtable->references = 1;
*dbtablep = dbtable;
return (ISC_R_SUCCESS);
clean3:
DESTROYLOCK(&dbtable->lock);
clean2:
dns_rbt_destroy(&dbtable->rbt);
clean1:
isc_mem_putanddetach(&mctx, dbtable, sizeof(*dbtable));
return (result);
}
static void ldapdb_lock(int what) {
static isc_mutex_t lock;
switch (what) {
case 0:
isc_mutex_init(&lock);
break;
case 1:
LOCK(&lock);
break;
case -1:
UNLOCK(&lock);
break;
}
}
isc_result_t
dns_keytable_create(isc_mem_t *mctx, dns_keytable_t **keytablep) {
dns_keytable_t *keytable;
isc_result_t result;
/*
* Create a keytable.
*/
REQUIRE(keytablep != NULL && *keytablep == NULL);
keytable = isc_mem_get(mctx, sizeof(*keytable));
if (keytable == NULL)
return (ISC_R_NOMEMORY);
keytable->table = NULL;
result = dns_rbt_create(mctx, free_keynode, mctx, &keytable->table);
if (result != ISC_R_SUCCESS)
goto cleanup_keytable;
result = isc_mutex_init(&keytable->lock);
if (result != ISC_R_SUCCESS)
goto cleanup_rbt;
result = isc_rwlock_init(&keytable->rwlock, 0, 0);
if (result != ISC_R_SUCCESS)
goto cleanup_lock;
keytable->mctx = NULL;
isc_mem_attach(mctx, &keytable->mctx);
keytable->active_nodes = 0;
keytable->references = 1;
keytable->magic = KEYTABLE_MAGIC;
*keytablep = keytable;
return (ISC_R_SUCCESS);
cleanup_lock:
DESTROYLOCK(&keytable->lock);
cleanup_rbt:
dns_rbt_destroy(&keytable->table);
cleanup_keytable:
isc_mem_putanddetach(&mctx, keytable, sizeof(*keytable));
return (result);
}
static void
initialize_action(void) {
isc_result_t result;
RUNTIME_CHECK(isc_mutex_init(&lock) == ISC_R_SUCCESS);
ISC_LIST_INIT(tables);
result = register_table(ISC_RESULTCLASS_ISC, ISC_R_NRESULTS, text,
isc_msgcat, ISC_RESULT_RESULTSET);
if (result != ISC_R_SUCCESS)
UNEXPECTED_ERROR(__FILE__, __LINE__,
"register_table() %s: %u",
isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
ISC_MSG_FAILED, "failed"),
result);
}
isc_result_t dns_dampening_init(dns_view_t * view, int initial_size) {
isc_result_t result;
int i, num_workers = sizeof(implementations)/sizeof(*implementations);
INSIST( view != NULL );
INSIST( view->dampening == NULL );
RUNTIME_CHECK( 0 < initial_size && initial_size <= ISC_UINT16_MAX );
view->dampening = isc_mem_get(view->mctx, sizeof(*(view->dampening)));
if( view->dampening == NULL ) {
result = ISC_R_NOMEMORY;
goto cleanup;
}
memset( view->dampening, 0, sizeof(*(view->dampening)) );
view->dampening->workers = isc_mem_get(view->mctx, num_workers * sizeof(*(view->dampening->workers)));
if( view->dampening->workers == NULL ) {
result = ISC_R_NOMEMORY;
goto cleanup;
}
memset( view->dampening->workers, 0, num_workers * sizeof(*(view->dampening->workers)) );
for(i = 0; i < num_workers; i++) {
result = implementations[i](view->mctx,
view->dampening->workers + i,
view->dampening, initial_size);
if( ISC_R_SUCCESS != result) {
dns_dampening_destroy( view );
goto cleanup;
}
result = isc_mutex_init(&view->dampening->workers[i].lock);
if( result != ISC_R_SUCCESS ) {
dns_dampening_destroy( view );
goto cleanup;
}
}
view->dampening->workers_count = num_workers;
INSIST( view->dampening != NULL );
result = ISC_R_SUCCESS;
cleanup:
return result;
}
isc_result_t
isc_mutexblock_init(isc_mutex_t *block, unsigned int count) {
isc_result_t result;
unsigned int i;
for (i = 0; i < count; i++) {
result = isc_mutex_init(&block[i]);
if (result != ISC_R_SUCCESS) {
while (i > 0U) {
i--;
DESTROYLOCK(&block[i]);
}
return (result);
}
}
return (ISC_R_SUCCESS);
}
static void
initialize(void) {
isc_result_t result;
REQUIRE(initialize_done == ISC_FALSE);
result = isc_mem_create(0, 0, &dns_g_mctx);
if (result != ISC_R_SUCCESS)
return;
dns_result_register();
#ifndef WIN32
result = dns_ecdb_register(dns_g_mctx, &dbimp);
if (result != ISC_R_SUCCESS)
goto cleanup_mctx;
#endif
result = isc_hash_create(dns_g_mctx, NULL, DNS_NAME_MAXWIRE);
if (result != ISC_R_SUCCESS)
goto cleanup_db;
result = dst_lib_init(dns_g_mctx, NULL, 0);
if (result != ISC_R_SUCCESS)
goto cleanup_hash;
result = isc_mutex_init(&reflock);
if (result != ISC_R_SUCCESS)
goto cleanup_dst;
initialize_done = ISC_TRUE;
return;
cleanup_dst:
dst_lib_destroy();
cleanup_hash:
isc_hash_destroy();
cleanup_db:
#ifndef WIN32
if (dbimp != NULL)
dns_ecdb_unregister(&dbimp);
cleanup_mctx:
#endif
if (dns_g_mctx != NULL)
isc_mem_detach(&dns_g_mctx);
}
/*
* Initialize a semaphore.
*
* sem - allocated semaphore that will be initialized
* value - number of times we can acquire the semaphore.
*/
isc_result_t
semaphore_init(semaphore_t *sem, int value)
{
isc_result_t result;
REQUIRE(sem != NULL);
REQUIRE(value > 0);
sem->value = value;
result = isc_mutex_init(&sem->mutex);
if (result != ISC_R_SUCCESS)
return result;
result = isc_condition_init(&sem->cond);
if (result != ISC_R_SUCCESS)
DESTROYLOCK(&sem->mutex);
return result;
}
ISC_APPFUNC_SCOPE isc_result_t
isc__app_ctxstart(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
isc_result_t result;
REQUIRE(VALID_APPCTX(ctx));
/*
* Start an ISC library application.
*/
#ifdef NEED_PTHREAD_INIT
/*
* BSDI 3.1 seg faults in pthread_sigmask() if we don't do this.
*/
presult = pthread_init();
if (presult != 0) {
isc__strerror(presult, strbuf, sizeof(strbuf));
UNEXPECTED_ERROR(__FILE__, __LINE__,
"isc_app_start() pthread_init: %s", strbuf);
return (ISC_R_UNEXPECTED);
}
#endif
#ifdef HAVE_LINUXTHREADS
main_thread = pthread_self();
#endif
result = isc_mutex_init(&ctx->lock);
if (result != ISC_R_SUCCESS)
return (result);
ISC_LIST_INIT(ctx->on_run);
ctx->shutdown_requested = ISC_FALSE;
ctx->running = ISC_FALSE;
ctx->want_shutdown = ISC_FALSE;
ctx->want_reload = ISC_FALSE;
ctx->blocked = ISC_FALSE;
return (ISC_R_SUCCESS);
}
isc_result_t
dns_badcache_init(isc_mem_t *mctx, unsigned int size, dns_badcache_t **bcp) {
isc_result_t result;
dns_badcache_t *bc = NULL;
REQUIRE(bcp != NULL && *bcp == NULL);
REQUIRE(mctx != NULL);
bc = isc_mem_get(mctx, sizeof(dns_badcache_t));
if (bc == NULL)
return (ISC_R_NOMEMORY);
memset(bc, 0, sizeof(dns_badcache_t));
isc_mem_attach(mctx, &bc->mctx);
result = isc_mutex_init(&bc->lock);
if (result != ISC_R_SUCCESS)
goto cleanup;
bc->table = isc_mem_get(bc->mctx, sizeof(*bc->table) * size);
if (bc->table == NULL) {
result = ISC_R_NOMEMORY;
goto destroy_lock;
}
bc->size = bc->minsize = size;
memset(bc->table, 0, bc->size * sizeof(dns_bcentry_t *));
bc->count = 0;
bc->sweep = 0;
bc->magic = BADCACHE_MAGIC;
*bcp = bc;
return (ISC_R_SUCCESS);
destroy_lock:
DESTROYLOCK(&bc->lock);
cleanup:
isc_mem_putanddetach(&bc->mctx, bc, sizeof(dns_badcache_t));
return (result);
}
isc_result_t
new_ldap_cache(isc_mem_t *mctx, ldap_cache_t **cachep,
const char * const *argv)
{
isc_result_t result;
ldap_cache_t *cache = NULL;
unsigned int cache_ttl;
setting_t cache_settings[] = {
{ "cache_ttl", default_uint(120) },
end_of_settings
};
REQUIRE(cachep != NULL && *cachep == NULL);
cache_settings[0].target = &cache_ttl;
CHECK(set_settings(cache_settings, argv));
CHECKED_MEM_GET_PTR(mctx, cache);
ZERO_PTR(cache);
isc_mem_attach(mctx, &cache->mctx);
isc_interval_set(&cache->cache_ttl, cache_ttl, 0);
if (cache_ttl) {
CHECK(dns_rbt_create(mctx, cache_node_deleter, NULL,
&cache->rbt));
CHECK(isc_mutex_init(&cache->mutex));
}
*cachep = cache;
return ISC_R_SUCCESS;
cleanup:
if (cache != NULL)
destroy_ldap_cache(&cache);
return result;
}
isc_result_t
isc_app_start(void) {
isc_result_t result;
/*
* Start an ISC library application.
*/
main_thread = GetCurrentThread();
result = isc_mutex_init(&lock);
if (result != ISC_R_SUCCESS)
return (result);
/* Create the reload event in a non-signaled state */
hEvents[RELOAD_EVENT] = CreateEvent(NULL, FALSE, FALSE, NULL);
/* Create the shutdown event in a non-signaled state */
hEvents[SHUTDOWN_EVENT] = CreateEvent(NULL, FALSE, FALSE, NULL);
ISC_LIST_INIT(on_run);
return (ISC_R_SUCCESS);
}
isc_result_t
dns_ssutable_create(isc_mem_t *mctx, dns_ssutable_t **tablep) {
isc_result_t result;
dns_ssutable_t *table;
REQUIRE(tablep != NULL && *tablep == NULL);
REQUIRE(mctx != NULL);
table = isc_mem_get(mctx, sizeof(dns_ssutable_t));
if (table == NULL)
return (ISC_R_NOMEMORY);
result = isc_mutex_init(&table->lock);
if (result != ISC_R_SUCCESS) {
isc_mem_put(mctx, table, sizeof(dns_ssutable_t));
return (result);
}
table->references = 1;
table->mctx = mctx;
ISC_LIST_INIT(table->rules);
table->magic = SSUTABLEMAGIC;
*tablep = table;
return (ISC_R_SUCCESS);
}
/**
* Allocate new set of settings, fill it with values from specified default set
* and (optionally) link the new set of settings to its parent set.
*
* @param[in] default_settings Array with pre-filled setting structures.
* @param[in] default_set_length Default set length in bytes.
* @param[in] set_name Human readable name for this set of settings.
*
* @pre target != NULL && *target == NULL
* @pre default_settings != NULL
* @pre default_set_length > 0, default_set_length <= sizeof(default_settings)
*
* @retval ISC_R_SUCCESS
* @retval ISC_R_NOMEMORY
*
* @note How to create local_settings which overrides default_settings:
* @code
* const setting_t default_settings[] = {
* { "connections", default_uint(2) },
* }
* const settings_set_t default_settings_set = {
* NULL,
* NULL,
* (setting_t *) &default_settings[0]
* };
* const setting_t local_settings[] = {
* { "connections", no_default_uint },
* }
*
* settings_set_t *local_settings = NULL;
* result = settings_set_create(mctx, default_settings,
* sizeof(default_settings), &default_settings_set,
* &local_settings);
* @endcode
*/
isc_result_t
settings_set_create(isc_mem_t *mctx, const setting_t default_settings[],
const unsigned int default_set_length, const char *set_name,
const settings_set_t *const parent_set,
settings_set_t **target) {
isc_result_t result = ISC_R_FAILURE;
settings_set_t *new_set = NULL;
REQUIRE(target != NULL && *target == NULL);
REQUIRE(default_settings != NULL);
REQUIRE(default_set_length > 0);
CHECKED_MEM_ALLOCATE(mctx, new_set, default_set_length);
ZERO_PTR(new_set);
isc_mem_attach(mctx, &new_set->mctx);
CHECKED_MEM_GET_PTR(mctx, new_set->lock);
result = isc_mutex_init(new_set->lock);
INSIST(result == ISC_R_SUCCESS);
new_set->parent_set = parent_set;
CHECKED_MEM_ALLOCATE(mctx, new_set->first_setting, default_set_length);
memcpy(new_set->first_setting, default_settings, default_set_length);
CHECKED_MEM_ALLOCATE(mctx, new_set->name, strlen(set_name) + 1);
strcpy(new_set->name, set_name);
*target = new_set;
result = ISC_R_SUCCESS;
cleanup:
if (result != ISC_R_SUCCESS)
settings_set_free(&new_set);
return result;
}
/*%
* Create methods
*/
static isc_result_t
create_stats(isc_mem_t *mctx, dns_statstype_t type, int ncounters,
dns_stats_t **statsp)
{
dns_stats_t *stats;
isc_result_t result;
stats = isc_mem_get(mctx, sizeof(*stats));
if (stats == NULL)
return (ISC_R_NOMEMORY);
stats->counters = NULL;
stats->references = 1;
result = isc_mutex_init(&stats->lock);
if (result != ISC_R_SUCCESS)
goto clean_stats;
result = isc_stats_create(mctx, &stats->counters, ncounters);
if (result != ISC_R_SUCCESS)
goto clean_mutex;
stats->magic = DNS_STATS_MAGIC;
stats->type = type;
stats->mctx = NULL;
isc_mem_attach(mctx, &stats->mctx);
*statsp = stats;
return (ISC_R_SUCCESS);
clean_mutex:
DESTROYLOCK(&stats->lock);
clean_stats:
isc_mem_put(mctx, stats, sizeof(*stats));
return (result);
}
static isc_result_t
listener_create(isc_mem_t *mctx, ns_lwresd_t *lwresd,
ns_lwreslistener_t **listenerp)
{
ns_lwreslistener_t *listener;
isc_result_t result;
REQUIRE(listenerp != NULL && *listenerp == NULL);
listener = isc_mem_get(mctx, sizeof(ns_lwreslistener_t));
if (listener == NULL)
return (ISC_R_NOMEMORY);
result = isc_mutex_init(&listener->lock);
if (result != ISC_R_SUCCESS) {
isc_mem_put(mctx, listener, sizeof(ns_lwreslistener_t));
return (result);
}
listener->magic = LWRESLISTENER_MAGIC;
listener->refs = 1;
listener->sock = NULL;
listener->manager = NULL;
ns_lwdmanager_attach(lwresd, &listener->manager);
listener->mctx = NULL;
isc_mem_attach(mctx, &listener->mctx);
ISC_LINK_INIT(listener, link);
ISC_LIST_INIT(listener->cmgrs);
*listenerp = listener;
return (ISC_R_SUCCESS);
}
