static isc_result_t
rdata_clone(isc_mem_t *mctx, dns_rdata_t *source, dns_rdata_t **targetp)
{
isc_result_t result;
dns_rdata_t *target = NULL;
isc_region_t target_region, source_region;
REQUIRE(mctx != NULL);
REQUIRE(source != NULL);
REQUIRE(targetp != NULL && *targetp == NULL);
CHECKED_MEM_GET_PTR(mctx, target);
dns_rdata_init(target);
dns_rdata_toregion(source, &source_region);
CHECKED_MEM_GET(mctx, target_region.base, source_region.length);
target_region.length = source_region.length;
memcpy(target_region.base, source_region.base, source_region.length);
dns_rdata_fromregion(target, source->rdclass, source->type,
&target_region);
*targetp = target;
return ISC_R_SUCCESS;
cleanup:
SAFE_MEM_PUT_PTR(mctx, target);
return result;
}
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
rdatalist_clone(isc_mem_t *mctx, dns_rdatalist_t *source,
dns_rdatalist_t **targetp)
{
dns_rdatalist_t *target;
dns_rdata_t *source_rdata;
dns_rdata_t *target_rdata;
isc_result_t result;
REQUIRE(mctx != NULL);
REQUIRE(source != NULL);
REQUIRE(targetp != NULL && *targetp == NULL);
CHECKED_MEM_GET_PTR(mctx, target);
dns_rdatalist_init(target);
target->rdclass = source->rdclass;
target->type = source->type;
target->covers = source->covers;
target->ttl = source->ttl;
source_rdata = HEAD(source->rdata);
while (source_rdata != NULL) {
target_rdata = NULL;
CHECK(rdata_clone(mctx, source_rdata, &target_rdata));
APPEND(target->rdata, target_rdata, link);
source_rdata = NEXT(source_rdata, link);
}
*targetp = target;
return ISC_R_SUCCESS;
cleanup:
if (target)
free_rdatalist(mctx, target);
SAFE_MEM_PUT_PTR(mctx, target);
return result;
}
isc_result_t
mldap_new(isc_mem_t *mctx, mldapdb_t **mldapp) {
isc_result_t result;
mldapdb_t *mldap = NULL;
REQUIRE(mldapp != NULL && *mldapp == NULL);
CHECKED_MEM_GET_PTR(mctx, mldap);
ZERO_PTR(mldap);
isc_mem_attach(mctx, &mldap->mctx);
CHECK(isc_refcount_init(&mldap->generation, 0));
CHECK(metadb_new(mctx, &mldap->mdb));
*mldapp = mldap;
return result;
cleanup:
metadb_destroy(&mldap->mdb);
MEM_PUT_AND_DETACH(mldap);
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;
}
/**
* 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;
}
static isc_result_t
cache_node_create(ldap_cache_t *cache, ldapdb_rdatalist_t rdatalist,
cache_node_t **nodep)
{
isc_result_t result;
cache_node_t *node;
REQUIRE(cache != NULL);
REQUIRE(nodep != NULL && *nodep == NULL);
CHECKED_MEM_GET_PTR(cache->mctx, node);
ZERO_PTR(node);
isc_mem_attach(cache->mctx, &node->mctx);
node->rdatalist = rdatalist;
CHECK(isc_time_nowplusinterval(&node->valid_until, &cache->cache_ttl));
*nodep = node;
return ISC_R_SUCCESS;
cleanup:
SAFE_MEM_PUT_PTR(cache->mctx, node);
return result;
}
/*
* Driver-specific implementation of dns_db_create().
*
* @param[in] argv Database-specific parameters from dns_db_create().
* @param[in] driverarg Driver-specific parameter from dns_db_register().
*/
isc_result_t
create_db(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
void *driverarg, dns_db_t **dbp)
{
sampledb_t *sampledb = NULL;
isc_result_t result;
dns_dbversion_t *version = NULL;
struct in_addr a_addr;
REQUIRE(type == dns_dbtype_zone);
REQUIRE(rdclass == dns_rdataclass_in);
REQUIRE(argc == 0);
REQUIRE(argv != NULL);
REQUIRE(driverarg != NULL); /* pointer to driver instance */
REQUIRE(dbp != NULL && *dbp == NULL);
UNUSED(driverarg); /* no driver-specific configuration */
a_addr.s_addr = 0x0100007fU;
CHECKED_MEM_GET_PTR(mctx, sampledb);
ZERO_PTR(sampledb);
isc_mem_attach(mctx, &sampledb->common.mctx);
dns_name_init(&sampledb->common.origin, NULL);
isc_ondestroy_init(&sampledb->common.ondest);
sampledb->common.magic = DNS_DB_MAGIC;
sampledb->common.impmagic = SAMPLEDB_MAGIC;
sampledb->common.methods = &sampledb_methods;
sampledb->common.attributes = 0;
sampledb->common.rdclass = rdclass;
CHECK(dns_name_dupwithoffsets(origin, mctx, &sampledb->common.origin));
CHECK(isc_refcount_init(&sampledb->refs, 1));
/* Translate instance name to instance pointer. */
sampledb->inst = driverarg;
/* Create internal instance of RBT DB implementation from BIND. */
CHECK(dns_db_create(mctx, "rbt", origin, dns_dbtype_zone,
dns_rdataclass_in, 0, NULL, &sampledb->rbtdb));
/* Create fake SOA, NS, and A records to make database loadable. */
CHECK(dns_db_newversion(sampledb->rbtdb, &version));
CHECK(add_soa(sampledb->rbtdb, version, origin, origin, origin));
CHECK(add_ns(sampledb->rbtdb, version, origin, origin));
CHECK(add_a(sampledb->rbtdb, version, origin, a_addr));
dns_db_closeversion(sampledb->rbtdb, &version, ISC_TRUE);
*dbp = (dns_db_t *)sampledb;
return (ISC_R_SUCCESS);
cleanup:
if (sampledb != NULL) {
if (dns_name_dynamic(&sampledb->common.origin))
dns_name_free(&sampledb->common.origin, mctx);
isc_mem_putanddetach(&sampledb->common.mctx, sampledb,
sizeof(*sampledb));
}
return (result);
}
