Rename ldap_db_t to ldap_instance_t

Equivalent to:
s/new_ldap_db/new_ldap_instance/
s/destroy_ldap_db/destroy_ldap_instance/
s/manager_get_ldap_db_and_cache/manager_get_ldap_instance_and_cache/
s/ldap_db_t/ldap_instance_t/
s/ldap_db/ldap_db/

9 files changed, 193 insertions, 193 deletions

diff --git a/src/cache.c b/src/cache.c
index 40a2289..e4c3aef 100644
--- a/src/cache.c
+++ b/src/cache.c
@@ -164,7 +164,7 @@ destroy_ldap_cache(ldap_cache_t **cachep)
 
 isc_result_t
 cached_ldap_rdatalist_get(isc_mem_t *mctx, ldap_cache_t *cache,
-			  ldap_db_t *ldap_db, dns_name_t *name,
+			  ldap_instance_t *ldap_inst, dns_name_t *name,
 			  dns_name_t *origin, ldapdb_rdatalist_t *rdatalist)
 {
 	isc_result_t result;
@@ -176,7 +176,7 @@ cached_ldap_rdatalist_get(isc_mem_t *mctx, ldap_cache_t *cache,
 	REQUIRE(cache != NULL);
 
 	if (cache->rbt == NULL)
-		return ldapdb_rdatalist_get(mctx, ldap_db, name, origin,
+		return ldapdb_rdatalist_get(mctx, ldap_inst, name, origin,
 					    rdatalist);
 
 	CONTROLED_LOCK(&cache->mutex);
@@ -201,7 +201,7 @@ cached_ldap_rdatalist_get(isc_mem_t *mctx, ldap_cache_t *cache,
 
 	if (!in_cache) {
 		INIT_LIST(rdlist);
-		result = ldapdb_rdatalist_get(mctx, ldap_db, name, origin,
+		result = ldapdb_rdatalist_get(mctx, ldap_inst, name, origin,
 					      &rdlist);
 		/* TODO: Cache entries that are not found. */
 		if (result != ISC_R_SUCCESS)
diff --git a/src/cache.h b/src/cache.h
index 74e4937..1089e74 100644
--- a/src/cache.h
+++ b/src/cache.h
@@ -45,7 +45,7 @@ destroy_ldap_cache(ldap_cache_t **cachep);
  */
 isc_result_t
 cached_ldap_rdatalist_get(isc_mem_t *mctx, ldap_cache_t *cache,
-			  ldap_db_t *ldap_db, dns_name_t *name,
+			  ldap_instance_t *ldap_inst, dns_name_t *name,
 			  dns_name_t *origin, ldapdb_rdatalist_t *rdatalist);
 
 /*
diff --git a/src/ldap_convert.c b/src/ldap_convert.c
index 8ce5e04..ff7a086 100644
--- a/src/ldap_convert.c
+++ b/src/ldap_convert.c
@@ -188,13 +188,13 @@ explode_rdn(const char *rdn, char ***explodedp, int notypes)
 }
 
 isc_result_t
-dnsname_to_dn(ldap_db_t *ldap_db, dns_name_t *name, ld_string_t *target)
+dnsname_to_dn(ldap_instance_t *ldap_inst, dns_name_t *name, ld_string_t *target)
 {
 	isc_result_t result;
 	int label_count;
 	const char *zone_dn = NULL;
 
-	REQUIRE(ldap_db != NULL);
+	REQUIRE(ldap_inst != NULL);
 	REQUIRE(name != NULL);
 	REQUIRE(target != NULL);
 
@@ -206,7 +206,7 @@ dnsname_to_dn(ldap_db_t *ldap_db, dns_name_t *name, ld_string_t *target)
 
 		INIT_BUFFERED_NAME(zone);
 
-		CHECK(get_zone_dn(ldap_db, name, &zone_dn, &zone));
+		CHECK(get_zone_dn(ldap_inst, name, &zone_dn, &zone));
 
 		dns_name_fullcompare(name, &zone, &dummy, &common_labels);
 		label_count = dns_name_countlabels(name) - common_labels;
diff --git a/src/ldap_convert.h b/src/ldap_convert.h
index d35144a..2d5ed0f 100644
--- a/src/ldap_convert.h
+++ b/src/ldap_convert.h
@@ -33,7 +33,7 @@
 isc_result_t dn_to_dnsname(isc_mem_t *mctx, const char *dn,
 			   dns_name_t *target);
 
-isc_result_t dnsname_to_dn(ldap_db_t *ldap_db, dns_name_t *name,
+isc_result_t dnsname_to_dn(ldap_instance_t *ldap_inst, dns_name_t *name,
 			   ld_string_t *target);
 
 isc_result_t ldap_record_to_rdatatype(const char *ldap_record,
diff --git a/src/ldap_driver.c b/src/ldap_driver.c
index c4ebed2..12b1db3 100644
--- a/src/ldap_driver.c
+++ b/src/ldap_driver.c
@@ -63,7 +63,7 @@ typedef struct {
 	dns_db_t			common;
 	isc_refcount_t			refs;
 	isc_mutex_t			lock; /* convert to isc_rwlock_t ? */
-	ldap_db_t			*ldap_db;
+	ldap_instance_t			*ldap_inst;
 	ldap_cache_t			*ldap_cache;
 } ldapdb_t;
 
@@ -315,7 +315,7 @@ findnode(dns_db_t *db, dns_name_t *name, isc_boolean_t create,
 	REQUIRE(VALID_LDAPDB(ldapdb));
 
 	result = cached_ldap_rdatalist_get(ldapdb->common.mctx,
-					   ldapdb->ldap_cache, ldapdb->ldap_db,
+					   ldapdb->ldap_cache, ldapdb->ldap_inst,
 					   name, &ldapdb->common.origin,
 					   &rdatalist);
 
@@ -373,7 +373,7 @@ find(dns_db_t *db, dns_name_t *name, dns_dbversion_t *version,
 	}
 
 	result = cached_ldap_rdatalist_get(ldapdb->common.mctx,
-					   ldapdb->ldap_cache, ldapdb->ldap_db,
+					   ldapdb->ldap_cache, ldapdb->ldap_inst,
 					   name, &ldapdb->common.origin,
 					   &rdatalist);
 	INSIST(result != DNS_R_PARTIALMATCH); /* XXX Not yet implemented */
@@ -659,7 +659,7 @@ addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
 		}
 	}
 
-	CHECK(write_to_ldap(&ldapdbnode->owner, ldapdb->ldap_db, new_rdlist));
+	CHECK(write_to_ldap(&ldapdbnode->owner, ldapdb->ldap_inst, new_rdlist));
 	CHECK(discard_from_cache(ldapdb->ldap_cache, &ldapdbnode->owner));
 
 	if (addedrdataset != NULL) {
@@ -747,7 +747,7 @@ subtractrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
 		goto cleanup;
 	}
 
-	CHECK(remove_from_ldap(&ldapdbnode->owner, ldapdb->ldap_db, &diff));
+	CHECK(remove_from_ldap(&ldapdbnode->owner, ldapdb->ldap_inst, &diff));
 	CHECK(discard_from_cache(ldapdb->ldap_cache, &ldapdbnode->owner));
 
 	if (newrdataset != NULL) {
@@ -998,7 +998,7 @@ ldapdb_create(isc_mem_t *mctx, dns_name_t *name, dns_dbtype_t type,
 	CHECK(dns_name_dupwithoffsets(name, mctx, &ldapdb->common.origin));
 
 	CHECK(isc_refcount_init(&ldapdb->refs, 1));
-	CHECK(manager_get_ldap_db_and_cache(argv[0], &ldapdb->ldap_db,
+	CHECK(manager_get_ldap_instance_and_cache(argv[0], &ldapdb->ldap_inst,
 					    &ldapdb->ldap_cache));
 
 	*dbp = (dns_db_t *)ldapdb;
@@ -1028,7 +1028,7 @@ dynamic_driver_init(isc_mem_t *mctx, const char *name, const char * const *argv,
 		    dns_dyndb_arguments_t *dyndb_args)
 {
 	isc_result_t result;
-	ldap_db_t *ldap_db = NULL;
+	ldap_instance_t *ldap_inst = NULL;
 	ldap_cache_t *ldap_cache = NULL;
 	dns_view_t *view;
 	dns_zonemgr_t *zmgr;
@@ -1067,9 +1067,9 @@ dynamic_driver_init(isc_mem_t *mctx, const char *name, const char * const *argv,
 	if (result != ISC_R_SUCCESS && result != ISC_R_EXISTS)
 		return result;
 
-	CHECK(new_ldap_db(mctx, view, &ldap_db, argv));
+	CHECK(new_ldap_instance(mctx, view, &ldap_inst, argv));
 	CHECK(new_ldap_cache(mctx, &ldap_cache, argv));
-	CHECK(manager_add_db_instance(mctx, name, ldap_db, ldap_cache, zmgr));
+	CHECK(manager_add_db_instance(mctx, name, ldap_inst, ldap_cache, zmgr));
 
 	/*
 	 * TODO: now fetch all zones and initialize ldap zone manager
@@ -1084,8 +1084,8 @@ dynamic_driver_init(isc_mem_t *mctx, const char *name, const char * const *argv,
 	return ISC_R_SUCCESS;
 
 cleanup:
-	if (ldap_db != NULL)
-		destroy_ldap_db(&ldap_db);
+	if (ldap_inst != NULL)
+		destroy_ldap_instance(&ldap_inst);
 	if (ldap_cache != NULL)
 		destroy_ldap_cache(&ldap_cache);
 
diff --git a/src/ldap_helper.c b/src/ldap_helper.c
index 245a521..ca35795 100644
--- a/src/ldap_helper.c
+++ b/src/ldap_helper.c
@@ -98,7 +98,7 @@ struct ldap_auth_pair {
 };
 
 /* These are typedefed in ldap_helper.h */
-struct ldap_db {
+struct ldap_instance {
 	isc_mem_t		*mctx;
 	dns_view_t		*view;
 
@@ -128,7 +128,7 @@ struct ldap_db {
 };
 
 struct ldap_connection {
-	ldap_db_t		*database;
+	ldap_instance_t		*database;
 	isc_mutex_t		lock;
 	LINK(ldap_connection_t)	link;
 	ld_string_t		*query_string;
@@ -199,10 +199,10 @@ const ldap_auth_pair_t supported_ldap_auth[] = {
 
 /* TODO: reorganize this stuff & clean it up. */
 void string_deleter(void *arg1, void *arg2);
-static isc_result_t new_ldap_connection(ldap_db_t *ldap_db,
+static isc_result_t new_ldap_connection(ldap_instance_t *ldap_inst,
 		ldap_connection_t **ldap_connp);
 static void destroy_ldap_connection(ldap_connection_t **ldap_connp);
-static isc_result_t add_or_modify_zone(ldap_db_t *ldap_db, const char *dn,
+static isc_result_t add_or_modify_zone(ldap_instance_t *ldap_inst, const char *dn,
 		const char *db_name, const char *update_str,
 		dns_zonemgr_t *zmgr);
 
@@ -247,7 +247,7 @@ static const LDAPMessage *next_entry(ldap_connection_t *inst);
 static const char *get_dn(ldap_connection_t *inst);
 #endif
 
-static ldap_connection_t * get_connection(ldap_db_t *ldap_db);
+static ldap_connection_t * get_connection(ldap_instance_t *ldap_inst);
 static void put_connection(ldap_connection_t *ldap_conn);
 static isc_result_t ldap_connect(ldap_connection_t *ldap_conn);
 static isc_result_t ldap_reconnect(ldap_connection_t *ldap_conn);
@@ -267,16 +267,16 @@ static void free_ldapmod(isc_mem_t *mctx, LDAPMod **changep);
 static isc_result_t ldap_rdata_to_char_array(isc_mem_t *mctx,
 		dns_rdata_t *rdata_head, char ***valsp);
 static void free_char_array(isc_mem_t *mctx, char ***valsp);
-static isc_result_t modify_ldap_common(dns_name_t *owner, ldap_db_t *ldap_db,
+static isc_result_t modify_ldap_common(dns_name_t *owner, ldap_instance_t *ldap_inst,
 		dns_rdatalist_t *rdlist, int mod_op);
 
 isc_result_t
-new_ldap_db(isc_mem_t *mctx, dns_view_t *view, ldap_db_t **ldap_dbp,
+new_ldap_instance(isc_mem_t *mctx, dns_view_t *view, ldap_instance_t **ldap_instp,
 	    const char * const *argv)
 {
 	unsigned int i;
 	isc_result_t result;
-	ldap_db_t *ldap_db;
+	ldap_instance_t *ldap_inst;
 	ldap_connection_t *ldap_conn;
 	ld_string_t *auth_method_str = NULL;
 	setting_t ldap_settings[] = {
@@ -296,68 +296,68 @@ new_ldap_db(isc_mem_t *mctx, dns_view_t *view, ldap_db_t **ldap_dbp,
 
 	REQUIRE(mctx != NULL);
 	REQUIRE(view != NULL);
-	REQUIRE(ldap_dbp != NULL && *ldap_dbp == NULL);
+	REQUIRE(ldap_instp != NULL && *ldap_instp == NULL);
 
-	ldap_db = isc_mem_get(mctx, sizeof(ldap_db_t));
-	if (ldap_db == NULL)
+	ldap_inst = isc_mem_get(mctx, sizeof(ldap_instance_t));
+	if (ldap_inst == NULL)
 		return ISC_R_NOMEMORY;
 
-	ZERO_PTR(ldap_db);
+	ZERO_PTR(ldap_inst);
 
-	isc_mem_attach(mctx, &ldap_db->mctx);
-	ldap_db->view = view;
+	isc_mem_attach(mctx, &ldap_inst->mctx);
+	ldap_inst->view = view;
 	/* commented out for now, cause named to hang */
-	//dns_view_attach(view, &ldap_db->view);
+	//dns_view_attach(view, &ldap_inst->view);
 
-	INIT_LIST(ldap_db->conn_list);
+	INIT_LIST(ldap_inst->conn_list);
 
-	CHECK(isc_rwlock_init(&ldap_db->zone_rwlock, 0, 0));
-	CHECK(dns_rbt_create(mctx, string_deleter, mctx, &ldap_db->zone_names));
+	CHECK(isc_rwlock_init(&ldap_inst->zone_rwlock, 0, 0));
+	CHECK(dns_rbt_create(mctx, string_deleter, mctx, &ldap_inst->zone_names));
 
-	CHECK(isc_mutex_init(&ldap_db->kinit_lock));
+	CHECK(isc_mutex_init(&ldap_inst->kinit_lock));
 
 	CHECK(str_new(mctx, &auth_method_str));
-	CHECK(str_new(mctx, &ldap_db->uri));
-	CHECK(str_new(mctx, &ldap_db->base));
-	CHECK(str_new(mctx, &ldap_db->bind_dn));
-	CHECK(str_new(mctx, &ldap_db->password));
-	CHECK(str_new(mctx, &ldap_db->sasl_mech));
-	CHECK(str_new(mctx, &ldap_db->sasl_user));
-	CHECK(str_new(mctx, &ldap_db->sasl_realm));
-	CHECK(str_new(mctx, &ldap_db->krb5_keytab));
+	CHECK(str_new(mctx, &ldap_inst->uri));
+	CHECK(str_new(mctx, &ldap_inst->base));
+	CHECK(str_new(mctx, &ldap_inst->bind_dn));
+	CHECK(str_new(mctx, &ldap_inst->password));
+	CHECK(str_new(mctx, &ldap_inst->sasl_mech));
+	CHECK(str_new(mctx, &ldap_inst->sasl_user));
+	CHECK(str_new(mctx, &ldap_inst->sasl_realm));
+	CHECK(str_new(mctx, &ldap_inst->krb5_keytab));
 
 	i = 0;
-	ldap_settings[i++].target = ldap_db->uri;
-	ldap_settings[i++].target = &ldap_db->connections;
-	ldap_settings[i++].target = &ldap_db->reconnect_interval;
-	ldap_settings[i++].target = ldap_db->base;
+	ldap_settings[i++].target = ldap_inst->uri;
+	ldap_settings[i++].target = &ldap_inst->connections;
+	ldap_settings[i++].target = &ldap_inst->reconnect_interval;
+	ldap_settings[i++].target = ldap_inst->base;
 	ldap_settings[i++].target = auth_method_str;
-	ldap_settings[i++].target = ldap_db->bind_dn;
-	ldap_settings[i++].target = ldap_db->password;
-	ldap_settings[i++].target = ldap_db->sasl_mech;
-	ldap_settings[i++].target = ldap_db->sasl_user;
-	ldap_settings[i++].target = ldap_db->sasl_realm;
-	ldap_settings[i++].target = ldap_db->krb5_keytab;
+	ldap_settings[i++].target = ldap_inst->bind_dn;
+	ldap_settings[i++].target = ldap_inst->password;
+	ldap_settings[i++].target = ldap_inst->sasl_mech;
+	ldap_settings[i++].target = ldap_inst->sasl_user;
+	ldap_settings[i++].target = ldap_inst->sasl_realm;
+	ldap_settings[i++].target = ldap_inst->krb5_keytab;
 
 	CHECK(set_settings(ldap_settings, argv));
 
 	/* Validate and check settings. */
-	str_toupper(ldap_db->sasl_mech);
-	if (ldap_db->connections < 1) {
+	str_toupper(ldap_inst->sasl_mech);
+	if (ldap_inst->connections < 1) {
 		log_error("at least one connection is required");
 		result = ISC_R_FAILURE;
 		goto cleanup;
 	}
 	/* Select authentication method. */
-	ldap_db->auth_method = AUTH_INVALID;
+	ldap_inst->auth_method = AUTH_INVALID;
 	for (i = 0; supported_ldap_auth[i].name != NULL; i++) {
 		if (!str_casecmp_char(auth_method_str,
 				      supported_ldap_auth[i].name)) {
-			ldap_db->auth_method = supported_ldap_auth[i].value;
+			ldap_inst->auth_method = supported_ldap_auth[i].value;
 			break;
 		}
 	}
-	if (ldap_db->auth_method == AUTH_INVALID) {
+	if (ldap_inst->auth_method == AUTH_INVALID) {
 		log_error("unknown authentication method '%s'",
 			  str_buf(auth_method_str));
 		result = ISC_R_FAILURE;
@@ -365,30 +365,30 @@ new_ldap_db(isc_mem_t *mctx, dns_view_t *view, ldap_db_t **ldap_dbp,
 	}
 
 	/* check we have the right data when SASL/GSSAPI is selected */
-	if ((ldap_db->auth_method == AUTH_SASL) &&
-	     (str_casecmp_char(ldap_db->sasl_mech, "GSSAPI") == 0)) {
-		if ((ldap_db->sasl_user == NULL) ||
-		    (str_len(ldap_db->sasl_user) == 0)) {
+	if ((ldap_inst->auth_method == AUTH_SASL) &&
+	     (str_casecmp_char(ldap_inst->sasl_mech, "GSSAPI") == 0)) {
+		if ((ldap_inst->sasl_user == NULL) ||
+		    (str_len(ldap_inst->sasl_user) == 0)) {
 			log_error("Sasl mech GSSAPI defined but sasl_user is empty");
 			result = ISC_R_FAILURE;
 			goto cleanup;
 		}
 	}
 
-	CHECK(semaphore_init(&ldap_db->conn_semaphore, ldap_db->connections));
+	CHECK(semaphore_init(&ldap_inst->conn_semaphore, ldap_inst->connections));
 
-	for (i = 0; i < ldap_db->connections; i++) {
+	for (i = 0; i < ldap_inst->connections; i++) {
 		ldap_conn = NULL;
-		CHECK(new_ldap_connection(ldap_db, &ldap_conn));
+		CHECK(new_ldap_connection(ldap_inst, &ldap_conn));
 		ldap_connect(ldap_conn);
-		APPEND(ldap_db->conn_list, ldap_conn, link);
+		APPEND(ldap_inst->conn_list, ldap_conn, link);
 	}
 
 cleanup:
 	if (result != ISC_R_SUCCESS)
-		destroy_ldap_db(&ldap_db);
+		destroy_ldap_instance(&ldap_inst);
 	else
-		*ldap_dbp = ldap_db;
+		*ldap_instp = ldap_inst;
 
 	str_destroy(&auth_method_str);
 
@@ -396,75 +396,75 @@ cleanup:
 }
 
 void
-destroy_ldap_db(ldap_db_t **ldap_dbp)
+destroy_ldap_instance(ldap_instance_t **ldap_instp)
 {
-	ldap_db_t *ldap_db;
+	ldap_instance_t *ldap_inst;
 	ldap_connection_t *elem;
 	ldap_connection_t *next;
 
-	REQUIRE(ldap_dbp != NULL && *ldap_dbp != NULL);
+	REQUIRE(ldap_instp != NULL && *ldap_instp != NULL);
 
-	ldap_db = *ldap_dbp;
+	ldap_inst = *ldap_instp;
 
-	elem = HEAD(ldap_db->conn_list);
+	elem = HEAD(ldap_inst->conn_list);
 	while (elem != NULL) {
 		next = NEXT(elem, link);
-		UNLINK(ldap_db->conn_list, elem, link);
+		UNLINK(ldap_inst->conn_list, elem, link);
 		destroy_ldap_connection(&elem);
 		elem = next;
 	}
 
-	str_destroy(&ldap_db->uri);
-	str_destroy(&ldap_db->base);
-	str_destroy(&ldap_db->bind_dn);
-	str_destroy(&ldap_db->password);
-	str_destroy(&ldap_db->sasl_mech);
-	str_destroy(&ldap_db->sasl_user);
-	str_destroy(&ldap_db->sasl_realm);
-	str_destroy(&ldap_db->krb5_keytab);
+	str_destroy(&ldap_inst->uri);
+	str_destroy(&ldap_inst->base);
+	str_destroy(&ldap_inst->bind_dn);
+	str_destroy(&ldap_inst->password);
+	str_destroy(&ldap_inst->sasl_mech);
+	str_destroy(&ldap_inst->sasl_user);
+	str_destroy(&ldap_inst->sasl_realm);
+	str_destroy(&ldap_inst->krb5_keytab);
 
-	semaphore_destroy(&ldap_db->conn_semaphore);
+	semaphore_destroy(&ldap_inst->conn_semaphore);
 	/* commented out for now, causes named to hang */
-	//dns_view_detach(&ldap_db->view);
+	//dns_view_detach(&ldap_inst->view);
 
-	DESTROYLOCK(&ldap_db->kinit_lock);
+	DESTROYLOCK(&ldap_inst->kinit_lock);
 
-	dns_rbt_destroy(&ldap_db->zone_names);
-	isc_rwlock_destroy(&ldap_db->zone_rwlock);
+	dns_rbt_destroy(&ldap_inst->zone_names);
+	isc_rwlock_destroy(&ldap_inst->zone_rwlock);
 
-	isc_mem_putanddetach(&ldap_db->mctx, ldap_db, sizeof(ldap_db_t));
+	isc_mem_putanddetach(&ldap_inst->mctx, ldap_inst, sizeof(ldap_instance_t));
 
-	*ldap_dbp = NULL;
+	*ldap_instp = NULL;
 }
 
 static isc_result_t
-new_ldap_connection(ldap_db_t *ldap_db, ldap_connection_t **ldap_connp)
+new_ldap_connection(ldap_instance_t *ldap_inst, ldap_connection_t **ldap_connp)
 {
 	isc_result_t result;
 	ldap_connection_t *ldap_conn;
 
-	REQUIRE(ldap_db != NULL);
+	REQUIRE(ldap_inst != NULL);
 	REQUIRE(ldap_connp != NULL && *ldap_connp == NULL);
 
-	ldap_conn = isc_mem_get(ldap_db->mctx, sizeof(ldap_connection_t));
+	ldap_conn = isc_mem_get(ldap_inst->mctx, sizeof(ldap_connection_t));
 	if (ldap_conn == NULL)
 		return ISC_R_NOMEMORY;
 
 	ZERO_PTR(ldap_conn);
 
-	ldap_conn->database = ldap_db;
+	ldap_conn->database = ldap_inst;
 	INIT_LINK(ldap_conn, link);
 	result = isc_mutex_init(&ldap_conn->lock);
 	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(ldap_db->mctx, ldap_db, sizeof(ldap_connection_t));
+		isc_mem_put(ldap_inst->mctx, ldap_inst, sizeof(ldap_connection_t));
 		return result;
 	}
 
-	CHECK(str_new(ldap_db->mctx, &ldap_conn->query_string));
-	CHECK(str_new(ldap_db->mctx, &ldap_conn->base));
+	CHECK(str_new(ldap_inst->mctx, &ldap_conn->query_string));
+	CHECK(str_new(ldap_inst->mctx, &ldap_conn->base));
 
-	CHECK(isc_lex_create(ldap_db->mctx, TOKENSIZ, &ldap_conn->lex));
-	CHECKED_MEM_GET(ldap_db->mctx, ldap_conn->rdata_target_mem, MINTSIZ);
+	CHECK(isc_lex_create(ldap_inst->mctx, TOKENSIZ, &ldap_conn->lex));
+	CHECKED_MEM_GET(ldap_inst->mctx, ldap_conn->rdata_target_mem, MINTSIZ);
 
 	*ldap_connp = ldap_conn;
 
@@ -504,7 +504,7 @@ destroy_ldap_connection(ldap_connection_t **ldap_connp)
 
 /* TODO: Delete old zones. */
 isc_result_t
-refresh_zones_from_ldap(ldap_db_t *ldap_db, const char *name,
+refresh_zones_from_ldap(ldap_instance_t *ldap_inst, const char *name,
 			dns_zonemgr_t *zmgr)
 {
 	isc_result_t result = ISC_R_SUCCESS;
@@ -514,14 +514,14 @@ refresh_zones_from_ldap(ldap_db_t *ldap_db, const char *name,
 		"idnsName", "idnsUpdatePolicy", NULL
 	};
 
-	REQUIRE(ldap_db != NULL);
+	REQUIRE(ldap_inst != NULL);
 	REQUIRE(name != NULL);
 
 	log_debug(2, "refreshing list of zones");
 
-	ldap_conn = get_connection(ldap_db);
+	ldap_conn = get_connection(ldap_inst);
 
-	CHECK(ldap_query(ldap_conn, str_buf(ldap_db->base), LDAP_SCOPE_SUBTREE,
+	CHECK(ldap_query(ldap_conn, str_buf(ldap_inst->base), LDAP_SCOPE_SUBTREE,
 			 attrs, 0,
 			 "(&(objectClass=idnsZone)(idnsZoneActive=True))"));
 	CHECK(cache_query_results(ldap_conn));
@@ -540,7 +540,7 @@ refresh_zones_from_ldap(ldap_db_t *ldap_db, const char *name,
 		if (result == ISC_R_SUCCESS)
 			update_str = HEAD(values)->value;
 
-		result = add_or_modify_zone(ldap_db, dn, name, update_str,
+		result = add_or_modify_zone(ldap_inst, dn, name, update_str,
 					    zmgr);
 
 		/* TODO: move this to the add_or_modify_zone() */
@@ -599,20 +599,20 @@ string_deleter(void *arg1, void *arg2)
 }
 
 isc_result_t
-get_zone_dn(ldap_db_t *ldap_db, dns_name_t *name, const char **dn,
+get_zone_dn(ldap_instance_t *ldap_inst, dns_name_t *name, const char **dn,
 	    dns_name_t *matched_name)
 {
 	isc_result_t result;
 	dns_rbt_t *rbt;
 	void *data = NULL;
 
-	REQUIRE(ldap_db != NULL);
+	REQUIRE(ldap_inst != NULL);
 	REQUIRE(name != NULL);
 	REQUIRE(dn != NULL && *dn == NULL);
 	REQUIRE(matched_name != NULL);
 
-	RWLOCK(&ldap_db->zone_rwlock, isc_rwlocktype_read);
-	rbt = ldap_db->zone_names;
+	RWLOCK(&ldap_inst->zone_rwlock, isc_rwlocktype_read);
+	rbt = ldap_inst->zone_names;
 
 	result = dns_rbt_findname(rbt, name, 0, matched_name, &data);
 	if (result == DNS_R_PARTIALMATCH)
@@ -622,27 +622,27 @@ get_zone_dn(ldap_db_t *ldap_db, dns_name_t *name, const char **dn,
 		*dn = data;
 	}
 
-	RWUNLOCK(&ldap_db->zone_rwlock, isc_rwlocktype_read);
+	RWUNLOCK(&ldap_inst->zone_rwlock, isc_rwlocktype_read);
 
 	return result;
 }
 
 static isc_result_t
-add_zone_dn(ldap_db_t *ldap_db, dns_name_t *name, const char *dn)
+add_zone_dn(ldap_instance_t *ldap_inst, dns_name_t *name, const char *dn)
 {
 	isc_result_t result;
 	dns_rbt_t *rbt;
 	void *data = NULL;
 	char *new_dn = NULL;
 
-	REQUIRE(ldap_db != NULL);
+	REQUIRE(ldap_inst != NULL);
 	REQUIRE(name != NULL);
 	REQUIRE(dn != NULL);
 
-	RWLOCK(&ldap_db->zone_rwlock, isc_rwlocktype_write);
-	rbt = ldap_db->zone_names;
+	RWLOCK(&ldap_inst->zone_rwlock, isc_rwlocktype_write);
+	rbt = ldap_inst->zone_names;
 
-	CHECKED_MEM_STRDUP(ldap_db->mctx, dn, new_dn);
+	CHECKED_MEM_STRDUP(ldap_inst->mctx, dn, new_dn);
 
 	/* First make sure the node doesn't exist. */
 	result = dns_rbt_findname(rbt, name, 0, NULL, &data);
@@ -655,17 +655,17 @@ add_zone_dn(ldap_db_t *ldap_db, dns_name_t *name, const char *dn)
 	CHECK(dns_rbt_addname(rbt, name, (void *)new_dn));
 
 cleanup:
-	RWUNLOCK(&ldap_db->zone_rwlock, isc_rwlocktype_write);
+	RWUNLOCK(&ldap_inst->zone_rwlock, isc_rwlocktype_write);
 
 	if (result != ISC_R_SUCCESS && new_dn != NULL)
-		isc_mem_free(ldap_db->mctx, new_dn);
+		isc_mem_free(ldap_inst->mctx, new_dn);
 
 	return result;
 }
 
 /* FIXME: Better error handling. */
 static isc_result_t
-add_or_modify_zone(ldap_db_t *ldap_db, const char *dn, const char *db_name,
+add_or_modify_zone(ldap_instance_t *ldap_inst, const char *dn, const char *db_name,
 		   const char *update_str, dns_zonemgr_t *zmgr)
 {
 	isc_result_t result;
@@ -673,7 +673,7 @@ add_or_modify_zone(ldap_db_t *ldap_db, const char *dn, const char *db_name,
 	dns_name_t name;
 	const char *argv[2];
 
-	REQUIRE(ldap_db != NULL);
+	REQUIRE(ldap_inst != NULL);
 	REQUIRE(dn != NULL);
 	REQUIRE(db_name != NULL);
 
@@ -683,20 +683,20 @@ add_or_modify_zone(ldap_db_t *ldap_db, const char *dn, const char *db_name,
 	zone = NULL;
 	dns_name_init(&name, NULL);
 
-	CHECK(dn_to_dnsname(ldap_db->mctx, dn, &name));
+	CHECK(dn_to_dnsname(ldap_inst->mctx, dn, &name));
 
 	/* If the zone doesn't exist, create it. */
-	result = dns_view_findzone(ldap_db->view, &name, &zone);
+	result = dns_view_findzone(ldap_inst->view, &name, &zone);
 	if (result == ISC_R_NOTFOUND) {
-		CHECK(dns_zone_create(&zone, ldap_db->mctx));
-		dns_zone_setview(zone, ldap_db->view);
+		CHECK(dns_zone_create(&zone, ldap_inst->mctx));
+		dns_zone_setview(zone, ldap_inst->view);
 		CHECK(dns_zone_setorigin(zone, &name));
 		dns_zone_setclass(zone, dns_rdataclass_in);
 		dns_zone_settype(zone, dns_zone_master);
 		CHECK(dns_zone_setdbtype(zone, 2, argv));
 		CHECK(dns_zonemgr_managezone(zmgr, zone));
-		CHECK(dns_view_addzone(ldap_db->view, zone));
-		CHECK(add_zone_dn(ldap_db, &name, dn));
+		CHECK(dns_view_addzone(ldap_inst->view, zone));
+		CHECK(add_zone_dn(ldap_inst, &name, dn));
 	} else if (result != ISC_R_SUCCESS) {
 		goto cleanup;
 	}
@@ -721,7 +721,7 @@ add_or_modify_zone(ldap_db_t *ldap_db, const char *dn, const char *db_name,
 
 cleanup:
 	if (dns_name_dynamic(&name))
-		dns_name_free(&name, ldap_db->mctx);
+		dns_name_free(&name, ldap_inst->mctx);
 	if (zone != NULL)
 		dns_zone_detach(&zone);
 
@@ -828,7 +828,7 @@ free_rdatalist(isc_mem_t *mctx, dns_rdatalist_t *rdlist)
 }
 
 isc_result_t
-ldapdb_rdatalist_get(isc_mem_t *mctx, ldap_db_t *ldap_db, dns_name_t *name,
+ldapdb_rdatalist_get(isc_mem_t *mctx, ldap_instance_t *ldap_inst, dns_name_t *name,
 		     dns_name_t *origin, ldapdb_rdatalist_t *rdatalist)
 {
 	isc_result_t result;
@@ -844,15 +844,15 @@ ldapdb_rdatalist_get(isc_mem_t *mctx, ldap_db_t *ldap_db, dns_name_t *name,
 	dns_rdatalist_t *rdlist = NULL;
 
 	REQUIRE(mctx != NULL);
-	REQUIRE(ldap_db != NULL);
+	REQUIRE(ldap_inst != NULL);
 	REQUIRE(name != NULL);
 	REQUIRE(rdatalist != NULL);
 
-	ldap_conn = get_connection(ldap_db);
+	ldap_conn = get_connection(ldap_inst);
 
 	INIT_LIST(*rdatalist);
 	CHECK(str_new(mctx, &string));
-	CHECK(dnsname_to_dn(ldap_db, name, string));
+	CHECK(dnsname_to_dn(ldap_inst, name, string));
 
 	CHECK(ldap_query(ldap_conn, str_buf(string), LDAP_SCOPE_BASE, NULL, 0,
 				"(objectClass=idnsRecord)"));
@@ -1178,14 +1178,14 @@ array_contains_nocase(const char **haystack, const char *needle)
 }
 
 static ldap_connection_t *
-get_connection(ldap_db_t *ldap_db)
+get_connection(ldap_instance_t *ldap_inst)
 {
 	ldap_connection_t *ldap_conn;
 
-	REQUIRE(ldap_db != NULL);
+	REQUIRE(ldap_inst != NULL);
 
-	semaphore_wait(&ldap_db->conn_semaphore);
-	ldap_conn = HEAD(ldap_db->conn_list);
+	semaphore_wait(&ldap_inst->conn_semaphore);
+	ldap_conn = HEAD(ldap_inst->conn_list);
 	while (ldap_conn != NULL) {
 		if (isc_mutex_trylock(&ldap_conn->lock) == ISC_R_SUCCESS)
 			break;
@@ -1196,7 +1196,7 @@ get_connection(ldap_db_t *ldap_db)
 
 	INIT_LIST(ldap_conn->ldap_entries);
 	/* TODO: find a clever way to not really require this */
-	str_copy(ldap_conn->base, ldap_db->base);
+	str_copy(ldap_conn->base, ldap_inst->base);
 
 	return ldap_conn;
 }
@@ -1471,10 +1471,10 @@ static int
 ldap_sasl_interact(LDAP *ld, unsigned flags, void *defaults, void *sin)
 {
 	sasl_interact_t *in = (sasl_interact_t *)sin;
-	ldap_db_t *ldap_db = (ldap_db_t *)defaults;
+	ldap_instance_t *ldap_inst = (ldap_instance_t *)defaults;
 	int ret = LDAP_OTHER;
 
-	REQUIRE(ldap_db != NULL);
+	REQUIRE(ldap_inst != NULL);
 	UNUSED(flags);
 
 	if (ld == NULL || sin == NULL)
@@ -1484,8 +1484,8 @@ ldap_sasl_interact(LDAP *ld, unsigned flags, void *defaults, void *sin)
 		switch (in->id) {
 		case SASL_CB_USER:
 			log_error("SASL_CB_USER");
-			in->result = str_buf(ldap_db->sasl_user);
-			in->len = str_len(ldap_db->sasl_user);
+			in->result = str_buf(ldap_inst->sasl_user);
+			in->len = str_len(ldap_inst->sasl_user);
 			ret = LDAP_SUCCESS;
 			break;
 		case SASL_CB_NOECHOPROMPT:
@@ -1508,14 +1508,14 @@ ldap_sasl_interact(LDAP *ld, unsigned flags, void *defaults, void *sin)
 			break;
 		case SASL_CB_AUTHNAME:
 			log_error("SASL_CB_AUTHNAME");
-			in->result = str_buf(ldap_db->sasl_user);
-			in->len = str_len(ldap_db->sasl_user);
+			in->result = str_buf(ldap_inst->sasl_user);
+			in->len = str_len(ldap_inst->sasl_user);
 			ret = LDAP_SUCCESS;
 			break;
 		case SASL_CB_PASS:
 			log_error("SASL_CB_PASS");
-			in->result = str_buf(ldap_db->password);
-			in->len = str_len(ldap_db->password);
+			in->result = str_buf(ldap_inst->password);
+			in->len = str_len(ldap_inst->password);
 			ret = LDAP_SUCCESS;
 			break;
 		default:
@@ -1540,13 +1540,13 @@ ldap_connect(ldap_connection_t *ldap_conn)
 	LDAP *ld;
 	int ret;
 	int version;
-	ldap_db_t *ldap_db;
+	ldap_instance_t *ldap_inst;
 
 	REQUIRE(ldap_conn != NULL);
 
-	ldap_db = ldap_conn->database;
+	ldap_inst = ldap_conn->database;
 
-	ret = ldap_initialize(&ld, str_buf(ldap_db->uri));
+	ret = ldap_initialize(&ld, str_buf(ldap_inst->uri));
 	if (ret != LDAP_SUCCESS) {
 		log_error("LDAP initialization failed: %s",
 			  ldap_err2string(ret));
@@ -1558,7 +1558,7 @@ ldap_connect(ldap_connection_t *ldap_conn)
 	LDAP_OPT_CHECK(ret, "failed to set LDAP version");
 
 	/*
-	ret = ldap_set_option(ld, LDAP_OPT_TIMELIMIT, (void *)&ldap_db->timeout);
+	ret = ldap_set_option(ld, LDAP_OPT_TIMELIMIT, (void *)&ldap_inst->timeout);
 	LDAP_OPT_CHECK(ret, "failed to set timeout: %s", ldap_err2string(ret));
 	*/
 
@@ -1579,14 +1579,14 @@ static isc_result_t
 ldap_reconnect(ldap_connection_t *ldap_conn)
 {
 	int ret = 0;
-	ldap_db_t *ldap_db;
+	ldap_instance_t *ldap_inst;
 	const char *bind_dn = NULL;
 	const char *password = NULL;
 #if 0
 	struct berval *servercred = NULL;
 #endif
 
-	ldap_db = ldap_conn->database;
+	ldap_inst = ldap_conn->database;
 
 	if (ldap_conn->tries > 0) {
 		isc_time_t now;
@@ -1599,9 +1599,9 @@ ldap_reconnect(ldap_connection_t *ldap_conn)
 			return ISC_R_FAILURE;
 	}
 
-	if (str_len(ldap_db->bind_dn) > 0 && str_len(ldap_db->password) > 0) {
-		bind_dn = str_buf(ldap_db->bind_dn);
-		password = str_buf(ldap_db->password);
+	if (str_len(ldap_inst->bind_dn) > 0 && str_len(ldap_inst->password) > 0) {
+		bind_dn = str_buf(ldap_inst->bind_dn);
+		password = str_buf(ldap_inst->password);
 	}
 
 	/* Set the next possible reconnect time. */
@@ -1613,16 +1613,16 @@ ldap_reconnect(ldap_connection_t *ldap_conn)
 		const size_t ntimes = sizeof(intervals) / sizeof(intervals[0]);
 
 		i = ISC_MIN(ntimes - 1, ldap_conn->tries);
-		seconds = ISC_MIN(intervals[i], ldap_db->reconnect_interval);
+		seconds = ISC_MIN(intervals[i], ldap_inst->reconnect_interval);
 		isc_interval_set(&delay, seconds, 0);
 		isc_time_nowplusinterval(&ldap_conn->next_reconnect, &delay);
 	}
 
 	ldap_conn->tries++;
 	log_debug(2, "trying to establish LDAP connection to %s",
-		  str_buf(ldap_db->uri));
+		  str_buf(ldap_inst->uri));
 
-	switch (ldap_db->auth_method) {
+	switch (ldap_inst->auth_method) {
 	case AUTH_NONE:
 		ret = ldap_simple_bind_s(ldap_conn->handle, NULL, NULL);
 		break;
@@ -1631,23 +1631,23 @@ ldap_reconnect(ldap_connection_t *ldap_conn)
 		break;
 	case AUTH_SASL:
 
-		if (strcmp(str_buf(ldap_db->sasl_mech), "GSSAPI") == 0) {
+		if (strcmp(str_buf(ldap_inst->sasl_mech), "GSSAPI") == 0) {
 			isc_result_t result;
-			LOCK(&ldap_db->kinit_lock);
-			result = get_krb5_tgt(ldap_db->mctx,
-					      str_buf(ldap_db->sasl_user),
-					      str_buf(ldap_db->krb5_keytab));
-			UNLOCK(&ldap_db->kinit_lock);
+			LOCK(&ldap_inst->kinit_lock);
+			result = get_krb5_tgt(ldap_inst->mctx,
+					      str_buf(ldap_inst->sasl_user),
+					      str_buf(ldap_inst->krb5_keytab));
+			UNLOCK(&ldap_inst->kinit_lock);
 			if (result != ISC_R_SUCCESS)
 				return result;
 		}
 
-		log_error("%s", str_buf(ldap_db->sasl_mech));
+		log_error("%s", str_buf(ldap_inst->sasl_mech));
 		ret = ldap_sasl_interactive_bind_s(ldap_conn->handle, NULL,
-						   str_buf(ldap_db->sasl_mech),
+						   str_buf(ldap_inst->sasl_mech),
 						   NULL, NULL, LDAP_SASL_QUIET,
 						   ldap_sasl_interact,
-						   ldap_db);
+						   ldap_inst);
 		break;
 	default:
 		log_error("bug in ldap_connect(): unsupported "
@@ -1901,7 +1901,7 @@ cleanup:
  * this is allowed.
  */
 static isc_result_t
-modify_ldap_common(dns_name_t *owner, ldap_db_t *ldap_db,
+modify_ldap_common(dns_name_t *owner, ldap_instance_t *ldap_inst,
 		   dns_rdatalist_t *rdlist, int mod_op)
 {
 	isc_result_t result;
@@ -1910,17 +1910,17 @@ modify_ldap_common(dns_name_t *owner, ldap_db_t *ldap_db,
 	ld_string_t *owner_dn = NULL;
 	LDAPMod *change[3] = { NULL, NULL, NULL };
 
-	mctx = ldap_db->mctx;
+	mctx = ldap_inst->mctx;
 
 	if (rdlist->type == dns_rdatatype_soa) {
 		result = ISC_R_SUCCESS;
 		goto cleanup;
 	}
 
-	ldap_conn = get_connection(ldap_db);
+	ldap_conn = get_connection(ldap_inst);
 
 	CHECK(str_new(mctx, &owner_dn));
-	CHECK(dnsname_to_dn(ldap_db, owner, owner_dn));
+	CHECK(dnsname_to_dn(ldap_inst, owner, owner_dn));
 	CHECK(ldap_rdatalist_to_ldapmod(mctx, rdlist, &change[0], mod_op));
 
 	if (mod_op == LDAP_MOD_ADD) {
@@ -1940,14 +1940,14 @@ cleanup:
 }
 
 isc_result_t
-write_to_ldap(dns_name_t *owner, ldap_db_t *ldap_db, dns_rdatalist_t *rdlist)
+write_to_ldap(dns_name_t *owner, ldap_instance_t *ldap_inst, dns_rdatalist_t *rdlist)
 {
-	return modify_ldap_common(owner, ldap_db, rdlist, LDAP_MOD_ADD);
+	return modify_ldap_common(owner, ldap_inst, rdlist, LDAP_MOD_ADD);
 }
 
 isc_result_t
-remove_from_ldap(dns_name_t *owner, ldap_db_t *ldap_db,
+remove_from_ldap(dns_name_t *owner, ldap_instance_t *ldap_inst,
 		 dns_rdatalist_t *rdlist)
 {
-	return modify_ldap_common(owner, ldap_db, rdlist, LDAP_MOD_DELETE);
+	return modify_ldap_common(owner, ldap_inst, rdlist, LDAP_MOD_DELETE);
 }
diff --git a/src/ldap_helper.h b/src/ldap_helper.h
index 7d78e08..019938c 100644
--- a/src/ldap_helper.h
+++ b/src/ldap_helper.h
@@ -23,7 +23,7 @@
 
 #include <isc/util.h>
 
-typedef struct ldap_db		ldap_db_t;
+typedef struct ldap_instance	ldap_instance_t;
 
 /*
  * some nice words about ldapdb_rdatalist_t:
@@ -65,7 +65,7 @@ void free_rdatalist(isc_mem_t *mctx, dns_rdatalist_t *rdlist);
  * Free all dynamically allocated memory inside rdlist.
  */
 
-isc_result_t ldapdb_rdatalist_get(isc_mem_t *mctx, ldap_db_t *ldap_db,
+isc_result_t ldapdb_rdatalist_get(isc_mem_t *mctx, ldap_instance_t *ldap_inst,
 				  dns_name_t *name, dns_name_t *origin,
 				  ldapdb_rdatalist_t *rdatalist);
 /*
@@ -83,20 +83,20 @@ isc_result_t ldapdb_rdatalist_get(isc_mem_t *mctx, ldap_db_t *ldap_db,
  * DNS_R_PARTIALMATCH
  */
 
-isc_result_t new_ldap_db(isc_mem_t *mctx, dns_view_t *view, ldap_db_t **ldap_dbp,
+isc_result_t new_ldap_instance(isc_mem_t *mctx, dns_view_t *view, ldap_instance_t **ldap_instp,
 			 const char * const *argv);
-void destroy_ldap_db(ldap_db_t **ldap_db);
-isc_result_t refresh_zones_from_ldap(ldap_db_t *ldap_db, const char *name,
+void destroy_ldap_instance(ldap_instance_t **ldap_inst);
+isc_result_t refresh_zones_from_ldap(ldap_instance_t *ldap_inst, const char *name,
 				     dns_zonemgr_t *zmgr);
 
 isc_result_t
-get_zone_dn(ldap_db_t *ldap_db, dns_name_t *name, const char **dn,
+get_zone_dn(ldap_instance_t *ldap_inst, dns_name_t *name, const char **dn,
 	    dns_name_t *matched_name);
 
 /* Functions for writing to LDAP. */
-isc_result_t write_to_ldap(dns_name_t *owner, ldap_db_t *ldap_db,
+isc_result_t write_to_ldap(dns_name_t *owner, ldap_instance_t *ldap_inst,
 		dns_rdatalist_t *rdlist);
-isc_result_t remove_from_ldap(dns_name_t *owner, ldap_db_t *ldap_db,
+isc_result_t remove_from_ldap(dns_name_t *owner, ldap_instance_t *ldap_inst,
 		dns_rdatalist_t *rdlist);
 
 #endif /* !_LD_LDAP_HELPER_H_ */
diff --git a/src/zone_manager.c b/src/zone_manager.c
index 245a9c1..50f39a9 100644
--- a/src/zone_manager.c
+++ b/src/zone_manager.c
@@ -36,7 +36,7 @@
 struct db_instance {
 	isc_mem_t		*mctx;
 	char			*name;
-	ldap_db_t		*ldap_db;
+	ldap_instance_t		*ldap_inst;
 	ldap_cache_t		*ldap_cache;
 	dns_zonemgr_t		*dns_zone_manager;
 	LINK(db_instance_t)	link;
@@ -86,7 +86,7 @@ destroy_db_instance(db_instance_t **db_instp)
 
 	db_inst = *db_instp;
 
-	destroy_ldap_db(&db_inst->ldap_db);
+	destroy_ldap_instance(&db_inst->ldap_inst);
 	destroy_ldap_cache(&db_inst->ldap_cache);
 	if (db_inst->name != NULL)
 		isc_mem_free(db_inst->mctx, db_inst->name);
@@ -97,7 +97,7 @@ destroy_db_instance(db_instance_t **db_instp)
 }
 
 isc_result_t
-manager_add_db_instance(isc_mem_t *mctx, const char *name, ldap_db_t *ldap_db,
+manager_add_db_instance(isc_mem_t *mctx, const char *name, ldap_instance_t *ldap_inst,
 			ldap_cache_t *ldap_cache, dns_zonemgr_t *zmgr)
 {
 	isc_result_t result;
@@ -105,7 +105,7 @@ manager_add_db_instance(isc_mem_t *mctx, const char *name, ldap_db_t *ldap_db,
 
 	REQUIRE(mctx != NULL);
 	REQUIRE(name != NULL);
-	REQUIRE(ldap_db != NULL);
+	REQUIRE(ldap_inst != NULL);
 	REQUIRE(ldap_cache != NULL);
 	REQUIRE(zmgr != NULL);
 
@@ -127,7 +127,7 @@ manager_add_db_instance(isc_mem_t *mctx, const char *name, ldap_db_t *ldap_db,
 	CHECKED_MEM_STRDUP(mctx, name, db_inst->name);
 	db_inst->mctx = NULL;
 	isc_mem_attach(mctx, &db_inst->mctx);
-	db_inst->ldap_db = ldap_db;
+	db_inst->ldap_inst = ldap_inst;
 	db_inst->ldap_cache = ldap_cache;
 	db_inst->dns_zone_manager = zmgr;
 
@@ -135,7 +135,7 @@ manager_add_db_instance(isc_mem_t *mctx, const char *name, ldap_db_t *ldap_db,
 	APPEND(instance_list, db_inst, link);
 	UNLOCK(&instance_list_lock);
 
-	refresh_zones_from_ldap(ldap_db, name, zmgr);
+	refresh_zones_from_ldap(ldap_inst, name, zmgr);
 
 	return ISC_R_SUCCESS;
 
@@ -154,7 +154,7 @@ manager_refresh_zones(void)
 	LOCK(&instance_list_lock);
 	db_inst = HEAD(instance_list);
 	while (db_inst != NULL) {
-		refresh_zones_from_ldap(db_inst->ldap_db, db_inst->name,
+		refresh_zones_from_ldap(db_inst->ldap_inst, db_inst->name,
 					db_inst->dns_zone_manager);
 		db_inst = NEXT(db_inst, link);
 	}
@@ -163,14 +163,14 @@ manager_refresh_zones(void)
 }
 
 isc_result_t
-manager_get_ldap_db_and_cache(const char *name, ldap_db_t **ldap_db,
+manager_get_ldap_instance_and_cache(const char *name, ldap_instance_t **ldap_inst,
 			      ldap_cache_t **ldap_cache)
 {
 	isc_result_t result;
 	db_instance_t *db_inst;
 
 	REQUIRE(name != NULL);
-	REQUIRE(ldap_db != NULL);
+	REQUIRE(ldap_inst != NULL);
 	REQUIRE(ldap_cache != NULL);
 
 	isc_once_do(&initialize_once, initialize_manager);
@@ -178,7 +178,7 @@ manager_get_ldap_db_and_cache(const char *name, ldap_db_t **ldap_db,
 	db_inst = NULL;
 	CHECK(find_db_instance(name, &db_inst));
 
-	*ldap_db = db_inst->ldap_db;
+	*ldap_inst = db_inst->ldap_inst;
 	*ldap_cache = db_inst->ldap_cache;
 
 cleanup:
diff --git a/src/zone_manager.h b/src/zone_manager.h
index 353cb85..b7d15bf 100644
--- a/src/zone_manager.h
+++ b/src/zone_manager.h
@@ -30,11 +30,11 @@ typedef struct db_instance db_instance_t;
 void destroy_manager(void);
 
 isc_result_t
-manager_add_db_instance(isc_mem_t *mctx, const char *name, ldap_db_t *ldap_db,
+manager_add_db_instance(isc_mem_t *mctx, const char *name, ldap_instance_t *ldap_inst,
 			ldap_cache_t *ldap_cache, dns_zonemgr_t *zmgr);
 
 isc_result_t
-manager_get_ldap_db_and_cache(const char *name, ldap_db_t **ldap_db,
+manager_get_ldap_instance_and_cache(const char *name, ldap_instance_t **ldap_inst,
 			      ldap_cache_t **ldap_cache);
 
 #endif /* !_LD_ZONE_MANAGER_H_ */