From 86a2eb8fcc47bcc34fc51631d466af0c3e765e5a Mon Sep 17 00:00:00 2001 From: Martin Nagy Date: Thu, 2 Jul 2009 14:51:38 +0200 Subject: Rename ldap_instance_t to ldap_connection_t Equivalent to: s/ldap_instance/ldap_connection s/ldap_inst/ldap_conn This commit starts a series of larger code refactoring effort. More changes and renames will follow. --- src/ldap_helper.c | 343 +++++++++++++++++++++++++++--------------------------- src/ldap_helper.h | 1 - 2 files changed, 172 insertions(+), 172 deletions(-) (limited to 'src') diff --git a/src/ldap_helper.c b/src/ldap_helper.c index 4b40f35..245a521 100644 --- a/src/ldap_helper.c +++ b/src/ldap_helper.c @@ -74,6 +74,7 @@ * LDAP related typedefs and structs. */ +typedef struct ldap_connection ldap_connection_t; typedef struct ldap_auth_pair ldap_auth_pair_t; typedef struct settings settings_t; typedef struct ldap_value ldap_value_t; @@ -103,7 +104,7 @@ struct ldap_db { /* List of LDAP connections. */ semaphore_t conn_semaphore; - LIST(ldap_instance_t) conn_list; + LIST(ldap_connection_t) conn_list; /* Our own list of zones. */ isc_rwlock_t zone_rwlock; @@ -126,10 +127,10 @@ struct ldap_db { ld_string_t *krb5_keytab; }; -struct ldap_instance { +struct ldap_connection { ldap_db_t *database; isc_mutex_t lock; - LINK(ldap_instance_t) link; + LINK(ldap_connection_t) link; ld_string_t *query_string; ld_string_t *base; @@ -198,9 +199,9 @@ 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_instance(ldap_db_t *ldap_db, - ldap_instance_t **ldap_instp); -static void destroy_ldap_instance(ldap_instance_t **ldap_instp); +static isc_result_t new_ldap_connection(ldap_db_t *ldap_db, + 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, const char *db_name, const char *update_str, dns_zonemgr_t *zmgr); @@ -208,7 +209,7 @@ static isc_result_t add_or_modify_zone(ldap_db_t *ldap_db, const char *dn, static isc_result_t findrdatatype_or_create(isc_mem_t *mctx, ldapdb_rdatalist_t *rdatalist, ldap_entry_t *entry, dns_rdatatype_t rdtype, dns_rdatalist_t **rdlistp); -static isc_result_t add_soa_record(isc_mem_t *mctx, ldap_instance_t *ldap_inst, +static isc_result_t add_soa_record(isc_mem_t *mctx, ldap_connection_t *ldap_conn, dns_name_t *origin, ldap_entry_t *entry, ldapdb_rdatalist_t *rdatalist); static dns_rdataclass_t get_rdataclass(ldap_entry_t *ldap_entry); @@ -225,38 +226,38 @@ static isc_result_t get_next_rdatatype(ldap_entry_t *entry, ldap_attribute_t **attr, dns_rdatatype_t *rdtype); static isc_result_t get_next_rdatatext(ldap_attribute_t *attr, ld_string_t *rdata_text); -static isc_result_t parse_rdata(isc_mem_t *mctx, ldap_instance_t *ldap_inst, +static isc_result_t parse_rdata(isc_mem_t *mctx, ldap_connection_t *ldap_conn, dns_rdataclass_t rdclass, dns_rdatatype_t rdtype, dns_name_t *origin, const char *rdata_text, dns_rdata_t **rdatap); -static isc_result_t cache_query_results(ldap_instance_t *inst); -static isc_result_t fill_ldap_entry(ldap_instance_t *inst, +static isc_result_t cache_query_results(ldap_connection_t *inst); +static isc_result_t fill_ldap_entry(ldap_connection_t *inst, ldap_entry_t *ldap_entry); -static isc_result_t fill_ldap_attribute(ldap_instance_t *inst, +static isc_result_t fill_ldap_attribute(ldap_connection_t *inst, ldap_attribute_t *ldap_attr); -static void free_query_cache(ldap_instance_t *inst); +static void free_query_cache(ldap_connection_t *inst); static void free_ldap_attributes(isc_mem_t *mctx, ldap_entry_t *entry); static void free_ldap_values(isc_mem_t *mctx, ldap_attribute_t *attr); -static const char * get_dn(ldap_instance_t *ldap_inst, ldap_entry_t *entry); +static const char * get_dn(ldap_connection_t *ldap_conn, ldap_entry_t *entry); #if 0 -static const LDAPMessage *next_entry(ldap_instance_t *inst); -static const char *get_dn(ldap_instance_t *inst); +static const LDAPMessage *next_entry(ldap_connection_t *inst); +static const char *get_dn(ldap_connection_t *inst); #endif -static ldap_instance_t * get_connection(ldap_db_t *ldap_db); -static void put_connection(ldap_instance_t *ldap_inst); -static isc_result_t ldap_connect(ldap_instance_t *ldap_inst); -static isc_result_t ldap_reconnect(ldap_instance_t *ldap_inst); -static int handle_connection_error(ldap_instance_t *ldap_inst, +static ldap_connection_t * get_connection(ldap_db_t *ldap_db); +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); +static int handle_connection_error(ldap_connection_t *ldap_conn, isc_result_t *result); -static isc_result_t ldap_query(ldap_instance_t *ldap_inst, const char *base, +static isc_result_t ldap_query(ldap_connection_t *ldap_conn, const char *base, int scope, char **attrs, int attrsonly, const char *filter, ...); /* Functions for writing to LDAP. */ -static isc_result_t ldap_modify_do(ldap_instance_t *ldap_inst, const char *dn, +static isc_result_t ldap_modify_do(ldap_connection_t *ldap_conn, const char *dn, LDAPMod **mods); static isc_result_t ldap_rdttl_to_ldapmod(isc_mem_t *mctx, dns_rdatalist_t *rdlist, LDAPMod **changep); @@ -276,7 +277,7 @@ new_ldap_db(isc_mem_t *mctx, dns_view_t *view, ldap_db_t **ldap_dbp, 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[] = { { "uri", no_default_string }, @@ -377,10 +378,10 @@ new_ldap_db(isc_mem_t *mctx, dns_view_t *view, ldap_db_t **ldap_dbp, CHECK(semaphore_init(&ldap_db->conn_semaphore, ldap_db->connections)); for (i = 0; i < ldap_db->connections; i++) { - ldap_inst = NULL; - CHECK(new_ldap_instance(ldap_db, &ldap_inst)); - ldap_connect(ldap_inst); - APPEND(ldap_db->conn_list, ldap_inst, link); + ldap_conn = NULL; + CHECK(new_ldap_connection(ldap_db, &ldap_conn)); + ldap_connect(ldap_conn); + APPEND(ldap_db->conn_list, ldap_conn, link); } cleanup: @@ -398,8 +399,8 @@ void destroy_ldap_db(ldap_db_t **ldap_dbp) { ldap_db_t *ldap_db; - ldap_instance_t *elem; - ldap_instance_t *next; + ldap_connection_t *elem; + ldap_connection_t *next; REQUIRE(ldap_dbp != NULL && *ldap_dbp != NULL); @@ -409,7 +410,7 @@ destroy_ldap_db(ldap_db_t **ldap_dbp) while (elem != NULL) { next = NEXT(elem, link); UNLINK(ldap_db->conn_list, elem, link); - destroy_ldap_instance(&elem); + destroy_ldap_connection(&elem); elem = next; } @@ -437,68 +438,68 @@ destroy_ldap_db(ldap_db_t **ldap_dbp) } static isc_result_t -new_ldap_instance(ldap_db_t *ldap_db, ldap_instance_t **ldap_instp) +new_ldap_connection(ldap_db_t *ldap_db, ldap_connection_t **ldap_connp) { isc_result_t result; - ldap_instance_t *ldap_inst; + ldap_connection_t *ldap_conn; REQUIRE(ldap_db != NULL); - REQUIRE(ldap_instp != NULL && *ldap_instp == NULL); + REQUIRE(ldap_connp != NULL && *ldap_connp == NULL); - ldap_inst = isc_mem_get(ldap_db->mctx, sizeof(ldap_instance_t)); - if (ldap_inst == NULL) + ldap_conn = isc_mem_get(ldap_db->mctx, sizeof(ldap_connection_t)); + if (ldap_conn == NULL) return ISC_R_NOMEMORY; - ZERO_PTR(ldap_inst); + ZERO_PTR(ldap_conn); - ldap_inst->database = ldap_db; - INIT_LINK(ldap_inst, link); - result = isc_mutex_init(&ldap_inst->lock); + ldap_conn->database = ldap_db; + 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_instance_t)); + isc_mem_put(ldap_db->mctx, ldap_db, sizeof(ldap_connection_t)); return result; } - CHECK(str_new(ldap_db->mctx, &ldap_inst->query_string)); - CHECK(str_new(ldap_db->mctx, &ldap_inst->base)); + CHECK(str_new(ldap_db->mctx, &ldap_conn->query_string)); + CHECK(str_new(ldap_db->mctx, &ldap_conn->base)); - CHECK(isc_lex_create(ldap_db->mctx, TOKENSIZ, &ldap_inst->lex)); - CHECKED_MEM_GET(ldap_db->mctx, ldap_inst->rdata_target_mem, MINTSIZ); + CHECK(isc_lex_create(ldap_db->mctx, TOKENSIZ, &ldap_conn->lex)); + CHECKED_MEM_GET(ldap_db->mctx, ldap_conn->rdata_target_mem, MINTSIZ); - *ldap_instp = ldap_inst; + *ldap_connp = ldap_conn; return ISC_R_SUCCESS; cleanup: - destroy_ldap_instance(&ldap_inst); + destroy_ldap_connection(&ldap_conn); return result; } static void -destroy_ldap_instance(ldap_instance_t **ldap_instp) +destroy_ldap_connection(ldap_connection_t **ldap_connp) { - ldap_instance_t *ldap_inst; + ldap_connection_t *ldap_conn; - REQUIRE(ldap_instp != NULL && *ldap_instp != NULL); + REQUIRE(ldap_connp != NULL && *ldap_connp != NULL); - ldap_inst = *ldap_instp; - DESTROYLOCK(&ldap_inst->lock); - if (ldap_inst->handle != NULL) - ldap_unbind_ext_s(ldap_inst->handle, NULL, NULL); + ldap_conn = *ldap_connp; + DESTROYLOCK(&ldap_conn->lock); + if (ldap_conn->handle != NULL) + ldap_unbind_ext_s(ldap_conn->handle, NULL, NULL); - str_destroy(&ldap_inst->query_string); - str_destroy(&ldap_inst->base); + str_destroy(&ldap_conn->query_string); + str_destroy(&ldap_conn->base); - if (ldap_inst->lex != NULL) - isc_lex_destroy(&ldap_inst->lex); - if (ldap_inst->rdata_target_mem != NULL) { - isc_mem_put(ldap_inst->database->mctx, - ldap_inst->rdata_target_mem, MINTSIZ); + if (ldap_conn->lex != NULL) + isc_lex_destroy(&ldap_conn->lex); + if (ldap_conn->rdata_target_mem != NULL) { + isc_mem_put(ldap_conn->database->mctx, + ldap_conn->rdata_target_mem, MINTSIZ); } - isc_mem_put(ldap_inst->database->mctx, *ldap_instp, sizeof(ldap_instance_t)); - *ldap_instp = NULL; + isc_mem_put(ldap_conn->database->mctx, *ldap_connp, sizeof(ldap_connection_t)); + *ldap_connp = NULL; } /* TODO: Delete old zones. */ @@ -507,7 +508,7 @@ refresh_zones_from_ldap(ldap_db_t *ldap_db, const char *name, dns_zonemgr_t *zmgr) { isc_result_t result = ISC_R_SUCCESS; - ldap_instance_t *ldap_inst; + ldap_connection_t *ldap_conn; ldap_entry_t *entry; char *attrs[] = { "idnsName", "idnsUpdatePolicy", NULL @@ -518,21 +519,21 @@ refresh_zones_from_ldap(ldap_db_t *ldap_db, const char *name, log_debug(2, "refreshing list of zones"); - ldap_inst = get_connection(ldap_db); + ldap_conn = get_connection(ldap_db); - CHECK(ldap_query(ldap_inst, str_buf(ldap_db->base), LDAP_SCOPE_SUBTREE, + CHECK(ldap_query(ldap_conn, str_buf(ldap_db->base), LDAP_SCOPE_SUBTREE, attrs, 0, "(&(objectClass=idnsZone)(idnsZoneActive=True))")); - CHECK(cache_query_results(ldap_inst)); + CHECK(cache_query_results(ldap_conn)); - for (entry = HEAD(ldap_inst->ldap_entries); + for (entry = HEAD(ldap_conn->ldap_entries); entry != NULL; entry = NEXT(entry, link)) { const char *dn; const char *update_str = NULL; ldap_value_list_t values; - dn = get_dn(ldap_inst, entry); + dn = get_dn(ldap_conn, entry); /* Look if there's an update policy. */ result = get_values(entry, "idnsUpdatePolicy", &values); @@ -548,7 +549,7 @@ refresh_zones_from_ldap(ldap_db_t *ldap_db, const char *name, } cleanup: - put_connection(ldap_inst); + put_connection(ldap_conn); log_debug(2, "finished refreshing list of zones"); @@ -556,21 +557,21 @@ cleanup: } static const char * -get_dn(ldap_instance_t *ldap_inst, ldap_entry_t *entry) +get_dn(ldap_connection_t *ldap_conn, ldap_entry_t *entry) { if (entry->dn) { ldap_memfree(entry->dn); entry->dn = NULL; } - if (ldap_inst->handle) - entry->dn = ldap_get_dn(ldap_inst->handle, entry->entry); + if (ldap_conn->handle) + entry->dn = ldap_get_dn(ldap_conn->handle, entry->entry); return entry->dn; } #if 0 static const char * -get_dn(ldap_instance_t *inst) +get_dn(ldap_connection_t *inst) { if (inst->dn) { ldap_memfree(inst->dn); @@ -831,7 +832,7 @@ ldapdb_rdatalist_get(isc_mem_t *mctx, ldap_db_t *ldap_db, dns_name_t *name, dns_name_t *origin, ldapdb_rdatalist_t *rdatalist) { isc_result_t result; - ldap_instance_t *ldap_inst; + ldap_connection_t *ldap_conn; ldap_entry_t *entry; ldap_attribute_t *attr; ld_string_t *string = NULL; @@ -847,26 +848,26 @@ ldapdb_rdatalist_get(isc_mem_t *mctx, ldap_db_t *ldap_db, dns_name_t *name, REQUIRE(name != NULL); REQUIRE(rdatalist != NULL); - ldap_inst = get_connection(ldap_db); + ldap_conn = get_connection(ldap_db); INIT_LIST(*rdatalist); CHECK(str_new(mctx, &string)); CHECK(dnsname_to_dn(ldap_db, name, string)); - CHECK(ldap_query(ldap_inst, str_buf(string), LDAP_SCOPE_BASE, NULL, 0, + CHECK(ldap_query(ldap_conn, str_buf(string), LDAP_SCOPE_BASE, NULL, 0, "(objectClass=idnsRecord)")); - CHECK(cache_query_results(ldap_inst)); + CHECK(cache_query_results(ldap_conn)); - if (EMPTY(ldap_inst->ldap_entries)) { + if (EMPTY(ldap_conn->ldap_entries)) { result = ISC_R_NOTFOUND; goto cleanup; } - for (entry = HEAD(ldap_inst->ldap_entries); + for (entry = HEAD(ldap_conn->ldap_entries); entry != NULL; entry = NEXT(entry, link)) { - result = add_soa_record(mctx, ldap_inst, origin, entry, + result = add_soa_record(mctx, ldap_conn, origin, entry, rdatalist); if (result != ISC_R_SUCCESS && result != ISC_R_NOTFOUND) goto cleanup; @@ -883,7 +884,7 @@ ldapdb_rdatalist_get(isc_mem_t *mctx, ldap_db_t *ldap_db, dns_name_t *name, for (result = get_next_rdatatext(attr, string); result == ISC_R_SUCCESS; result = get_next_rdatatext(attr, string)) { - CHECK(parse_rdata(mctx, ldap_inst, rdclass, + CHECK(parse_rdata(mctx, ldap_conn, rdclass, rdtype, origin, str_buf(string), &rdata)); APPEND(rdlist->rdata, rdata, link); @@ -896,7 +897,7 @@ ldapdb_rdatalist_get(isc_mem_t *mctx, ldap_db_t *ldap_db, dns_name_t *name, result = ISC_R_SUCCESS; cleanup: - put_connection(ldap_inst); + put_connection(ldap_conn); str_destroy(&string); if (result != ISC_R_SUCCESS) @@ -969,7 +970,7 @@ cleanup: } static isc_result_t -add_soa_record(isc_mem_t *mctx, ldap_instance_t *ldap_inst, dns_name_t *origin, +add_soa_record(isc_mem_t *mctx, ldap_connection_t *ldap_conn, dns_name_t *origin, ldap_entry_t *entry, ldapdb_rdatalist_t *rdatalist) { isc_result_t result; @@ -984,7 +985,7 @@ add_soa_record(isc_mem_t *mctx, ldap_instance_t *ldap_inst, dns_name_t *origin, rdclass = get_rdataclass(entry); CHECK(get_soa_record(entry, string)); - CHECK(parse_rdata(mctx, ldap_inst, rdclass, dns_rdatatype_soa, origin, + CHECK(parse_rdata(mctx, ldap_conn, rdclass, dns_rdatatype_soa, origin, str_buf(string), &rdata)); CHECK(findrdatatype_or_create(mctx, rdatalist, entry, dns_rdatatype_soa, @@ -1045,7 +1046,7 @@ get_next_rdatatext(ldap_attribute_t *attr, ld_string_t *rdata_text) } static isc_result_t -parse_rdata(isc_mem_t *mctx, ldap_instance_t *ldap_inst, +parse_rdata(isc_mem_t *mctx, ldap_connection_t *ldap_conn, dns_rdataclass_t rdclass, dns_rdatatype_t rdtype, dns_name_t *origin, const char *rdata_text, dns_rdata_t **rdatap) { @@ -1056,7 +1057,7 @@ parse_rdata(isc_mem_t *mctx, ldap_instance_t *ldap_inst, dns_rdata_t *rdata; REQUIRE(mctx != NULL); - REQUIRE(ldap_inst != NULL); + REQUIRE(ldap_conn != NULL); REQUIRE(rdata_text != NULL); REQUIRE(rdatap != NULL); @@ -1070,30 +1071,30 @@ parse_rdata(isc_mem_t *mctx, ldap_instance_t *ldap_inst, isc_buffer_add(&lex_buffer, text.length); isc_buffer_setactive(&lex_buffer, text.length); - CHECK(isc_lex_openbuffer(ldap_inst->lex, &lex_buffer)); + CHECK(isc_lex_openbuffer(ldap_conn->lex, &lex_buffer)); - isc_buffer_init(&ldap_inst->rdata_target, ldap_inst->rdata_target_mem, + isc_buffer_init(&ldap_conn->rdata_target, ldap_conn->rdata_target_mem, MINTSIZ); - CHECK(dns_rdata_fromtext(NULL, rdclass, rdtype, ldap_inst->lex, origin, - 0, mctx, &ldap_inst->rdata_target, NULL)); + CHECK(dns_rdata_fromtext(NULL, rdclass, rdtype, ldap_conn->lex, origin, + 0, mctx, &ldap_conn->rdata_target, NULL)); CHECKED_MEM_GET_PTR(mctx, rdata); dns_rdata_init(rdata); - rdatamem.length = isc_buffer_usedlength(&ldap_inst->rdata_target); + rdatamem.length = isc_buffer_usedlength(&ldap_conn->rdata_target); CHECKED_MEM_GET(mctx, rdatamem.base, rdatamem.length); - memcpy(rdatamem.base, isc_buffer_base(&ldap_inst->rdata_target), + memcpy(rdatamem.base, isc_buffer_base(&ldap_conn->rdata_target), rdatamem.length); dns_rdata_fromregion(rdata, rdclass, rdtype, &rdatamem); - isc_lex_close(ldap_inst->lex); + isc_lex_close(ldap_conn->lex); *rdatap = rdata; return ISC_R_SUCCESS; cleanup: - isc_lex_close(ldap_inst->lex); + isc_lex_close(ldap_conn->lex); if (rdata != NULL) isc_mem_put(mctx, rdata, sizeof(*rdata)); if (rdatamem.base != NULL) @@ -1176,109 +1177,109 @@ array_contains_nocase(const char **haystack, const char *needle) return isc_boolean_false; } -static ldap_instance_t * +static ldap_connection_t * get_connection(ldap_db_t *ldap_db) { - ldap_instance_t *ldap_inst; + ldap_connection_t *ldap_conn; REQUIRE(ldap_db != NULL); semaphore_wait(&ldap_db->conn_semaphore); - ldap_inst = HEAD(ldap_db->conn_list); - while (ldap_inst != NULL) { - if (isc_mutex_trylock(&ldap_inst->lock) == ISC_R_SUCCESS) + ldap_conn = HEAD(ldap_db->conn_list); + while (ldap_conn != NULL) { + if (isc_mutex_trylock(&ldap_conn->lock) == ISC_R_SUCCESS) break; - ldap_inst = NEXT(ldap_inst, link); + ldap_conn = NEXT(ldap_conn, link); } - RUNTIME_CHECK(ldap_inst != NULL); + RUNTIME_CHECK(ldap_conn != NULL); - INIT_LIST(ldap_inst->ldap_entries); + INIT_LIST(ldap_conn->ldap_entries); /* TODO: find a clever way to not really require this */ - str_copy(ldap_inst->base, ldap_db->base); + str_copy(ldap_conn->base, ldap_db->base); - return ldap_inst; + return ldap_conn; } static void -put_connection(ldap_instance_t *ldap_inst) +put_connection(ldap_connection_t *ldap_conn) { - if (ldap_inst == NULL) + if (ldap_conn == NULL) return; - if (ldap_inst->dn) { - ldap_memfree(ldap_inst->dn); - ldap_inst->dn = NULL; + if (ldap_conn->dn) { + ldap_memfree(ldap_conn->dn); + ldap_conn->dn = NULL; } - if (ldap_inst->values) { - ldap_value_free(ldap_inst->values); - ldap_inst->values = NULL; + if (ldap_conn->values) { + ldap_value_free(ldap_conn->values); + ldap_conn->values = NULL; } - if (ldap_inst->attribute) { - ldap_memfree(ldap_inst->attribute); - ldap_inst->attribute = NULL; + if (ldap_conn->attribute) { + ldap_memfree(ldap_conn->attribute); + ldap_conn->attribute = NULL; } - if (ldap_inst->ber) { - ber_free(ldap_inst->ber, 0); - ldap_inst->ber = NULL; + if (ldap_conn->ber) { + ber_free(ldap_conn->ber, 0); + ldap_conn->ber = NULL; } - if (ldap_inst->result) { - ldap_msgfree(ldap_inst->result); - ldap_inst->result = NULL; + if (ldap_conn->result) { + ldap_msgfree(ldap_conn->result); + ldap_conn->result = NULL; } - free_query_cache(ldap_inst); + free_query_cache(ldap_conn); - UNLOCK(&ldap_inst->lock); - semaphore_signal(&ldap_inst->database->conn_semaphore); + UNLOCK(&ldap_conn->lock); + semaphore_signal(&ldap_conn->database->conn_semaphore); } static isc_result_t -ldap_query(ldap_instance_t *ldap_inst, const char *base, int scope, char **attrs, +ldap_query(ldap_connection_t *ldap_conn, const char *base, int scope, char **attrs, int attrsonly, const char *filter, ...) { va_list ap; isc_result_t result; - REQUIRE(ldap_inst != NULL); + REQUIRE(ldap_conn != NULL); va_start(ap, filter); - str_vsprintf(ldap_inst->query_string, filter, ap); + str_vsprintf(ldap_conn->query_string, filter, ap); va_end(ap); log_debug(2, "querying '%s' with '%s'", base, - str_buf(ldap_inst->query_string)); + str_buf(ldap_conn->query_string)); - if (ldap_inst->handle == NULL) { - log_error("bug in ldap_query(): ldap_inst->handle is NULL"); + if (ldap_conn->handle == NULL) { + log_error("bug in ldap_query(): ldap_conn->handle is NULL"); return ISC_R_FAILURE; } do { int ret; - ret = ldap_search_ext_s(ldap_inst->handle, base, scope, - str_buf(ldap_inst->query_string), + ret = ldap_search_ext_s(ldap_conn->handle, base, scope, + str_buf(ldap_conn->query_string), attrs, attrsonly, NULL, NULL, NULL, - LDAP_NO_LIMIT, &ldap_inst->result); + LDAP_NO_LIMIT, &ldap_conn->result); if (ret == 0) { int cnt; - ldap_inst->tries = 0; - cnt = ldap_count_entries(ldap_inst->handle, ldap_inst->result); + ldap_conn->tries = 0; + cnt = ldap_count_entries(ldap_conn->handle, ldap_conn->result); log_debug(2, "entry count: %d", cnt); return ISC_R_SUCCESS; } - } while (handle_connection_error(ldap_inst, &result)); + } while (handle_connection_error(ldap_conn, &result)); return result; } static isc_result_t -cache_query_results(ldap_instance_t *inst) +cache_query_results(ldap_connection_t *inst) { isc_result_t result; LDAP *ld; @@ -1321,7 +1322,7 @@ cleanup: } static isc_result_t -fill_ldap_entry(ldap_instance_t *inst, ldap_entry_t *ldap_entry) +fill_ldap_entry(ldap_connection_t *inst, ldap_entry_t *ldap_entry) { isc_result_t result; ldap_attribute_t *ldap_attr; @@ -1361,7 +1362,7 @@ cleanup: } static isc_result_t -fill_ldap_attribute(ldap_instance_t *inst, ldap_attribute_t *ldap_attr) +fill_ldap_attribute(ldap_connection_t *inst, ldap_attribute_t *ldap_attr) { isc_result_t result; char **values; @@ -1395,7 +1396,7 @@ cleanup: } static void -free_query_cache(ldap_instance_t *inst) +free_query_cache(ldap_connection_t *inst) { ldap_entry_t *entry, *next; @@ -1447,7 +1448,7 @@ free_ldap_values(isc_mem_t *mctx, ldap_attribute_t *attr) #if 0 /* FIXME: this function is obsolete, remove. */ static const LDAPMessage * -next_entry(ldap_instance_t *inst) +next_entry(ldap_connection_t *inst) { if (inst->ber) { ber_free(inst->ber, 0); @@ -1531,19 +1532,19 @@ ldap_sasl_interact(LDAP *ld, unsigned flags, void *defaults, void *sin) /* * Initialize the LDAP handle and bind to the server. Needed authentication - * credentials and settings are available from the ldap_inst->database. + * credentials and settings are available from the ldap_conn->database. */ static isc_result_t -ldap_connect(ldap_instance_t *ldap_inst) +ldap_connect(ldap_connection_t *ldap_conn) { LDAP *ld; int ret; int version; ldap_db_t *ldap_db; - REQUIRE(ldap_inst != NULL); + REQUIRE(ldap_conn != NULL); - ldap_db = ldap_inst->database; + ldap_db = ldap_conn->database; ret = ldap_initialize(&ld, str_buf(ldap_db->uri)); if (ret != LDAP_SUCCESS) { @@ -1561,8 +1562,8 @@ ldap_connect(ldap_instance_t *ldap_inst) LDAP_OPT_CHECK(ret, "failed to set timeout: %s", ldap_err2string(ret)); */ - ldap_inst->handle = ld; - ldap_reconnect(ldap_inst); + ldap_conn->handle = ld; + ldap_reconnect(ldap_conn); return ISC_R_SUCCESS; @@ -1575,7 +1576,7 @@ cleanup: } static isc_result_t -ldap_reconnect(ldap_instance_t *ldap_inst) +ldap_reconnect(ldap_connection_t *ldap_conn) { int ret = 0; ldap_db_t *ldap_db; @@ -1585,15 +1586,15 @@ ldap_reconnect(ldap_instance_t *ldap_inst) struct berval *servercred = NULL; #endif - ldap_db = ldap_inst->database; + ldap_db = ldap_conn->database; - if (ldap_inst->tries > 0) { + if (ldap_conn->tries > 0) { isc_time_t now; int time_cmp; isc_result_t result; result = isc_time_now(&now); - time_cmp = isc_time_compare(&now, &ldap_inst->next_reconnect); + time_cmp = isc_time_compare(&now, &ldap_conn->next_reconnect); if (result == ISC_R_SUCCESS && time_cmp < 0) return ISC_R_FAILURE; } @@ -1611,22 +1612,22 @@ ldap_reconnect(ldap_instance_t *ldap_inst) const unsigned int intervals[] = { 2, 5, 20, UINT_MAX }; const size_t ntimes = sizeof(intervals) / sizeof(intervals[0]); - i = ISC_MIN(ntimes - 1, ldap_inst->tries); + i = ISC_MIN(ntimes - 1, ldap_conn->tries); seconds = ISC_MIN(intervals[i], ldap_db->reconnect_interval); isc_interval_set(&delay, seconds, 0); - isc_time_nowplusinterval(&ldap_inst->next_reconnect, &delay); + isc_time_nowplusinterval(&ldap_conn->next_reconnect, &delay); } - ldap_inst->tries++; + ldap_conn->tries++; log_debug(2, "trying to establish LDAP connection to %s", str_buf(ldap_db->uri)); switch (ldap_db->auth_method) { case AUTH_NONE: - ret = ldap_simple_bind_s(ldap_inst->handle, NULL, NULL); + ret = ldap_simple_bind_s(ldap_conn->handle, NULL, NULL); break; case AUTH_SIMPLE: - ret = ldap_simple_bind_s(ldap_inst->handle, bind_dn, password); + ret = ldap_simple_bind_s(ldap_conn->handle, bind_dn, password); break; case AUTH_SASL: @@ -1642,7 +1643,7 @@ ldap_reconnect(ldap_instance_t *ldap_inst) } log_error("%s", str_buf(ldap_db->sasl_mech)); - ret = ldap_sasl_interactive_bind_s(ldap_inst->handle, NULL, + ret = ldap_sasl_interactive_bind_s(ldap_conn->handle, NULL, str_buf(ldap_db->sasl_mech), NULL, NULL, LDAP_SASL_QUIET, ldap_sasl_interact, @@ -1661,13 +1662,13 @@ ldap_reconnect(ldap_instance_t *ldap_inst) return ISC_R_FAILURE; } - ldap_inst->tries = 0; + ldap_conn->tries = 0; return ISC_R_SUCCESS; } static int -handle_connection_error(ldap_instance_t *ldap_inst, isc_result_t *result) +handle_connection_error(ldap_connection_t *ldap_conn, isc_result_t *result) { int ret; int err_code; @@ -1675,19 +1676,19 @@ handle_connection_error(ldap_instance_t *ldap_inst, isc_result_t *result) *result = ISC_R_FAILURE; - ret = ldap_get_option(ldap_inst->handle, LDAP_OPT_RESULT_CODE, + ret = ldap_get_option(ldap_conn->handle, LDAP_OPT_RESULT_CODE, (void *)&err_code); if (ret != LDAP_OPT_SUCCESS) { err_string = "failed to get error code"; } else if (err_code == LDAP_NO_SUCH_OBJECT) { *result = ISC_R_SUCCESS; - ldap_inst->tries = 0; + ldap_conn->tries = 0; return 0; } else if (err_code == LDAP_SERVER_DOWN) { - if (ldap_inst->tries == 0) + if (ldap_conn->tries == 0) log_error("connection to the LDAP server was lost"); - *result = ldap_reconnect(ldap_inst); + *result = ldap_reconnect(ldap_conn); if (*result == ISC_R_SUCCESS) return 1; } else { @@ -1703,21 +1704,21 @@ handle_connection_error(ldap_instance_t *ldap_inst, isc_result_t *result) /* FIXME: Handle the case where the LDAP handle is NULL -> try to reconnect. */ /* FIXME: Handle cases where the entry actually doesn't exist. */ static isc_result_t -ldap_modify_do(ldap_instance_t *ldap_inst, const char *dn, LDAPMod **mods) +ldap_modify_do(ldap_connection_t *ldap_conn, const char *dn, LDAPMod **mods) { int ret; - REQUIRE(ldap_inst != NULL); + REQUIRE(ldap_conn != NULL); REQUIRE(dn != NULL); REQUIRE(mods != NULL); log_debug(2, "writing to '%s'", dn); - ret = ldap_modify_ext_s(ldap_inst->handle, dn, mods, NULL, NULL); + ret = ldap_modify_ext_s(ldap_conn->handle, dn, mods, NULL, NULL); if (ret != LDAP_SUCCESS) { int err_code; - ldap_get_option(ldap_inst->handle, LDAP_OPT_RESULT_CODE, + ldap_get_option(ldap_conn->handle, LDAP_OPT_RESULT_CODE, &err_code); log_debug(2, "error(%s) modifying(%s) entry %s", ldap_err2string(err_code), @@ -1905,7 +1906,7 @@ modify_ldap_common(dns_name_t *owner, ldap_db_t *ldap_db, { isc_result_t result; isc_mem_t *mctx; - ldap_instance_t *ldap_inst = NULL; + ldap_connection_t *ldap_conn = NULL; ld_string_t *owner_dn = NULL; LDAPMod *change[3] = { NULL, NULL, NULL }; @@ -1916,7 +1917,7 @@ modify_ldap_common(dns_name_t *owner, ldap_db_t *ldap_db, goto cleanup; } - ldap_inst = get_connection(ldap_db); + ldap_conn = get_connection(ldap_db); CHECK(str_new(mctx, &owner_dn)); CHECK(dnsname_to_dn(ldap_db, owner, owner_dn)); @@ -1927,10 +1928,10 @@ modify_ldap_common(dns_name_t *owner, ldap_db_t *ldap_db, CHECK(ldap_rdttl_to_ldapmod(mctx, rdlist, &change[1])); } - CHECK(ldap_modify_do(ldap_inst, str_buf(owner_dn), change)); + CHECK(ldap_modify_do(ldap_conn, str_buf(owner_dn), change)); cleanup: - put_connection(ldap_inst); + put_connection(ldap_conn); str_destroy(&owner_dn); free_ldapmod(mctx, &change[0]); free_ldapmod(mctx, &change[1]); diff --git a/src/ldap_helper.h b/src/ldap_helper.h index 8c40772..7d78e08 100644 --- a/src/ldap_helper.h +++ b/src/ldap_helper.h @@ -24,7 +24,6 @@ #include typedef struct ldap_db ldap_db_t; -typedef struct ldap_instance ldap_instance_t; /* * some nice words about ldapdb_rdatalist_t: -- cgit