Hello, Support BIND 9.10.
https://fedorahosted.org/bind-dyndb-ldap/ticket/139 This patch definitely needs more testing but ...: - It compiles with BIND 9.9 and BIND 9.10. - It seems that it is able to load master and forward zones. - Basic dynamic updates work. I did not test other features yet. -- Petr^2 Spacek
From 7101194d6bcf99c8cc5c8fec405ee716cd6e7b07 Mon Sep 17 00:00:00 2001 From: Petr Spacek <[email protected]> Date: Thu, 4 Dec 2014 14:52:18 +0100 Subject: [PATCH] Support BIND 9.10. https://fedorahosted.org/bind-dyndb-ldap/ticket/139 --- src/acl.c | 29 ++++++++++--- src/acl.h | 7 ++- src/ldap_driver.c | 88 ++++++++++++++++++++++++++++++++++--- src/ldap_helper.c | 128 +++++++++++++++++++++++++++++++++++++++--------------- 4 files changed, 204 insertions(+), 48 deletions(-) diff --git a/src/acl.c b/src/acl.c index 449a5ad85186bc4e2309add77ff551897afac92b..233a3208dcb361b4b7c0cc8bd46a472d9b61939d 100644 --- a/src/acl.c +++ b/src/acl.c @@ -37,6 +37,8 @@ * PERFORMANCE OF THIS SOFTWARE. */ +#include "config.h" + #include <isccfg/aclconf.h> #include <isccfg/cfg.h> #include <isccfg/namedconf.h> @@ -47,9 +49,11 @@ #include <isc/mem.h> #include <isc/once.h> #include <isc/result.h> +#include <isc/types.h> #include <isc/util.h> #include <dns/fixedname.h> +#include <dns/forward.h> #include <dns/log.h> #include <dns/rdatatype.h> #include <dns/ssu.h> @@ -604,21 +608,27 @@ cleanup: * */ isc_result_t -acl_parse_forwarder(const char *forwarder_str, isc_mem_t *mctx, isc_sockaddr_t **sa) +acl_parse_forwarder(const char *forwarder_str, isc_mem_t *mctx, +#if LIBDNS_VERSION_MAJOR < 140 + isc_sockaddr_t **fw) +#else /* LIBDNS_VERSION_MAJOR >= 140 */ + dns_forwarder_t **fw) +#endif { isc_result_t result = ISC_R_SUCCESS; cfg_parser_t *parser = NULL; cfg_obj_t *forwarders_cfg = NULL; ld_string_t *new_forwarder_str = NULL; const cfg_obj_t *faddresses; const cfg_listelt_t *element; const cfg_obj_t *forwarder; + isc_sockaddr_t addr; in_port_t port = 53; REQUIRE(forwarder_str != NULL); - REQUIRE(sa != NULL && *sa == NULL); + REQUIRE(fw != NULL && *fw == NULL); /* add semicolon and brackets as necessary for parser */ if (!index(forwarder_str, ';')) @@ -637,10 +647,17 @@ acl_parse_forwarder(const char *forwarder_str, isc_mem_t *mctx, isc_sockaddr_t * } forwarder = cfg_listelt_value(element); - CHECKED_MEM_GET_PTR(mctx, *sa); - **sa = *cfg_obj_assockaddr(forwarder); - if (isc_sockaddr_getport(*sa) == 0) - isc_sockaddr_setport(*sa, port); + CHECKED_MEM_GET_PTR(mctx, *fw); + addr = *cfg_obj_assockaddr(forwarder); + if (isc_sockaddr_getport(&addr) == 0) + isc_sockaddr_setport(&addr, port); +#if LIBDNS_VERSION_MAJOR < 140 + **fw = addr; +#else /* LIBDNS_VERSION_MAJOR >= 140 */ + (*fw)->addr = addr; + (*fw)->dscp = cfg_obj_getdscp(forwarder); +#endif + cleanup: if (forwarders_cfg != NULL) diff --git a/src/acl.h b/src/acl.h index 9ca7644d792d6da6060bcb48e10e9c579d890503..e438132f623b4efb2c3e2d595b1d83065f8583dc 100644 --- a/src/acl.h +++ b/src/acl.h @@ -47,6 +47,11 @@ acl_from_ldap(isc_mem_t *mctx, const char *aclstr, acl_type_t type, isc_result_t acl_parse_forwarder(const char *forwarders_str, isc_mem_t *mctx, - isc_sockaddr_t **sa) ATTR_NONNULLS ATTR_CHECKRESULT; +#if LIBDNS_VERSION_MAJOR < 140 + isc_sockaddr_t **fw) +#else /* LIBDNS_VERSION_MAJOR >= 140 */ + dns_forwarder_t **fw) +#endif +ATTR_NONNULLS ATTR_CHECKRESULT; #endif /* !_LD_ACL_H_ */ diff --git a/src/ldap_driver.c b/src/ldap_driver.c index 6161c96938b429923aee983a37312f64260226de..8b78c960cfb05cc0f4c0fb50e3fbdaa9cfdcae50 100644 --- a/src/ldap_driver.c +++ b/src/ldap_driver.c @@ -198,12 +198,18 @@ detach(dns_db_t **dbp) /* !!! This could be required for optimizations (like on-disk cache). */ static isc_result_t +#if LIBDNS_VERSION_MAJOR < 140 beginload(dns_db_t *db, dns_addrdatasetfunc_t *addp, dns_dbload_t **dbloadp) { UNUSED(db); UNUSED(addp); UNUSED(dbloadp); +#else /* LIBDNS_VERSION_MAJOR >= 140 */ +beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) { + UNUSED(db); + UNUSED(callbacks); +#endif /* LIBDNS_VERSION_MAJOR >= 140 */ fatal_error("ldapdb: method beginload() should never be called"); @@ -218,18 +224,35 @@ beginload(dns_db_t *db, dns_addrdatasetfunc_t *addp, dns_dbload_t **dbloadp) /* !!! This could be required for optimizations (like on-disk cache). */ static isc_result_t +#if LIBDNS_VERSION_MAJOR < 140 endload(dns_db_t *db, dns_dbload_t **dbloadp) { UNUSED(db); UNUSED(dbloadp); +#else /* LIBDNS_VERSION_MAJOR >= 140 */ +endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) { + UNUSED(db); + UNUSED(callbacks); +#endif /* LIBDNS_VERSION_MAJOR >= 140 */ fatal_error("ldapdb: method endload() should never be called"); /* Not reached */ return ISC_R_SUCCESS; } +#if LIBDNS_VERSION_MAJOR >= 140 +static isc_result_t +serialize(dns_db_t *db, dns_dbversion_t *version, FILE *file) +{ + ldapdb_t *ldapdb = (ldapdb_t *) db; + + REQUIRE(VALID_LDAPDB(ldapdb)); + + return dns_db_serialize(ldapdb->rbtdb, version, file); +} +#endif /* LIBDNS_VERSION_MAJOR >= 140 */ /* !!! This could be required for optimizations (like on-disk cache). */ static isc_result_t @@ -780,7 +803,7 @@ getrrsetstats(dns_db_t *db) { } #endif /* LIBDNS_VERSION_MAJOR >= 45 */ -#if LIBDNS_VERSION_MAJOR >= 82 +#if LIBDNS_VERSION_MAJOR >= 82 && LIBDNS_VERSION_MAJOR < 140 static isc_result_t rpz_enabled(dns_db_t *db, dns_rpz_st_t *st) { @@ -804,7 +827,29 @@ rpz_findips(dns_rpz_zone_t *rpz, dns_rpz_type_t rpz_type, dns_db_rpz_findips(rpz, rpz_type, zone, ldapdb->rbtdb, version, ardataset, st, query_qname); } -#endif /* LIBDNS_VERSION_MAJOR >= 82 */ +#endif /* LIBDNS_VERSION_MAJOR >= 82 && LIBDNS_VERSION_MAJOR < 140 */ + +#if LIBDNS_VERSION_MAJOR >= 140 +void +rpz_attach(dns_db_t *db, dns_rpz_zones_t *rpzs, dns_rpz_num_t rpz_num) +{ + ldapdb_t *ldapdb = (ldapdb_t *) db; + + REQUIRE(VALID_LDAPDB(ldapdb)); + + dns_db_rpz_attach(ldapdb->rbtdb, rpzs, rpz_num); +} + +isc_result_t +rpz_ready(dns_db_t *db) +{ + ldapdb_t *ldapdb = (ldapdb_t *) db; + + REQUIRE(VALID_LDAPDB(ldapdb)); + + return dns_db_rpz_ready(ldapdb->rbtdb); +} +#endif /* LIBDNS_VERSION_MAJOR >= 140 */ #if LIBDNS_VERSION_MAJOR >= 90 static isc_result_t @@ -837,11 +882,36 @@ findext(dns_db_t *db, dns_name_t *name, dns_dbversion_t *version, } #endif /* LIBDNS_VERSION_MAJOR >= 90 */ +#if LIBDNS_VERSION_MAJOR >= 140 +isc_result_t +setcachestats(dns_db_t *db, isc_stats_t *stats) +{ + ldapdb_t *ldapdb = (ldapdb_t *) db; + + REQUIRE(VALID_LDAPDB(ldapdb)); + + return dns_db_setcachestats(ldapdb->rbtdb, stats); +} + +unsigned int +hashsize(dns_db_t *db) +{ + ldapdb_t *ldapdb = (ldapdb_t *) db; + + REQUIRE(VALID_LDAPDB(ldapdb)); + + return dns_db_hashsize(ldapdb->rbtdb); +} +#endif /* LIBDNS_VERSION_MAJOR >= 140 */ + static dns_dbmethods_t ldapdb_methods = { attach, detach, beginload, endload, +#if LIBDNS_VERSION_MAJOR >= 140 + serialize, /* see dns_db_serialize(), implementation is not mandatory */ +#endif /* LIBDNS_VERSION_MAJOR >= 140 */ dump, currentversion, newversion, @@ -880,14 +950,22 @@ static dns_dbmethods_t ldapdb_methods = { #endif /* LIBDNS_VERSION_MAJOR >= 50 */ getrrsetstats, #endif /* LIBDNS_VERSION_MAJOR >= 45 */ -#if LIBDNS_VERSION_MAJOR >= 82 +#if LIBDNS_VERSION_MAJOR >= 82 && LIBDNS_VERSION_MAJOR < 140 rpz_enabled, rpz_findips, -#endif /* LIBDNS_VERSION_MAJOR >= 82 */ +#endif /* LIBDNS_VERSION_MAJOR >= 82 && LIBDNS_VERSION_MAJOR < 140 */ +#if LIBDNS_VERSION_MAJOR >= 140 + rpz_attach, + rpz_ready, +#endif /* LIBDNS_VERSION_MAJOR >= 140 */ #if LIBDNS_VERSION_MAJOR >= 90 findnodeext, - findext + findext, #endif /* LIBDNS_VERSION_MAJOR >= 90 */ +#if LIBDNS_VERSION_MAJOR >= 140 + setcachestats, + hashsize +#endif /* LIBDNS_VERSION_MAJOR >= 140 */ }; isc_result_t ATTR_NONNULLS diff --git a/src/ldap_helper.c b/src/ldap_helper.c index ddb787c152b522118357bb6dc5542dce6af8ee0e..9427dfbee800bacf3960c623ede2a10a7bc988cb 100644 --- a/src/ldap_helper.c +++ b/src/ldap_helper.c @@ -20,6 +20,8 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +#include "config.h" + #include <dns/dynamic_db.h> #include <dns/diff.h> #include <dns/journal.h> @@ -143,6 +145,13 @@ struct ldap_auth_pair { char *name; /* String representation used in configuration file */ }; +/* BIND 9.10 changed forwarder representation in struct dns_forwarders */ +#if LIBDNS_VERSION_MAJOR < 140 + #define inst_fwdlist(inst) ((inst)->orig_global_forwarders.addrs) +#else /* LIBDNS_VERSION_MAJOR >= 140 */ + #define inst_fwdlist(inst) ((inst)->orig_global_forwarders.fwdrs) +#endif + /* These are typedefed in ldap_helper.h */ struct ldap_instance { isc_mem_t *mctx; @@ -537,7 +546,7 @@ new_ldap_instance(isc_mem_t *mctx, const char *db_name, view = dns_dyndb_get_view(dyndb_args); dns_view_attach(view, &ldap_inst->view); ldap_inst->zmgr = dns_dyndb_get_zonemgr(dyndb_args); - ISC_LIST_INIT(ldap_inst->orig_global_forwarders.addrs); + ISC_LIST_INIT(inst_fwdlist(ldap_inst)); ldap_inst->task = task; ldap_inst->watcher = 0; CHECK(sync_ctx_init(ldap_inst->mctx, ldap_inst, &ldap_inst->sctx)); @@ -574,16 +583,21 @@ new_ldap_instance(isc_mem_t *mctx, const char *db_name, result = dns_fwdtable_find(ldap_inst->view->fwdtable, dns_rootname, &orig_global_forwarders); if (result == ISC_R_SUCCESS) { - isc_sockaddr_t *addr; - isc_sockaddr_t *new_addr; - for (addr = ISC_LIST_HEAD(orig_global_forwarders->addrs); - addr != NULL; - addr = ISC_LIST_NEXT(addr, link)) { - CHECKED_MEM_GET_PTR(mctx, new_addr); - *new_addr = *addr; - ISC_LINK_INIT(new_addr, link); - ISC_LIST_APPEND(ldap_inst->orig_global_forwarders.addrs, - new_addr, link); +#if LIBDNS_VERSION_MAJOR < 140 + isc_sockaddr_t *fwdr; + isc_sockaddr_t *new_fwdr; + for (fwdr = ISC_LIST_HEAD(orig_global_forwarders->addrs); +#else /* LIBDNS_VERSION_MAJOR >= 140 */ + dns_forwarder_t *fwdr; + dns_forwarder_t *new_fwdr; + for (fwdr = ISC_LIST_HEAD(orig_global_forwarders->fwdrs); +#endif + fwdr != NULL; + fwdr = ISC_LIST_NEXT(fwdr, link)) { + CHECKED_MEM_GET_PTR(mctx, new_fwdr); + *new_fwdr = *fwdr; + ISC_LINK_INIT(new_fwdr, link); + ISC_LIST_APPEND(inst_fwdlist(ldap_inst), new_fwdr, link); } ldap_inst->orig_global_forwarders.fwdpolicy = orig_global_forwarders->fwdpolicy; @@ -621,7 +635,11 @@ destroy_ldap_instance(ldap_instance_t **ldap_instp) { ldap_instance_t *ldap_inst; const char *db_name; - isc_sockaddr_t *addr; +#if LIBDNS_VERSION_MAJOR < 140 + isc_sockaddr_t *fwdr; +#else /* LIBDNS_VERSION_MAJOR >= 140 */ + dns_forwarder_t *fwdr; +#endif REQUIRE(ldap_instp != NULL); @@ -656,10 +674,10 @@ destroy_ldap_instance(ldap_instance_t **ldap_instp) DESTROYLOCK(&ldap_inst->kinit_lock); - while (!ISC_LIST_EMPTY(ldap_inst->orig_global_forwarders.addrs)) { - addr = ISC_LIST_HEAD(ldap_inst->orig_global_forwarders.addrs); - ISC_LIST_UNLINK(ldap_inst->orig_global_forwarders.addrs, addr, link); - SAFE_MEM_PUT_PTR(ldap_inst->mctx, addr); + while (!ISC_LIST_EMPTY(inst_fwdlist(ldap_inst))) { + fwdr = ISC_LIST_HEAD(inst_fwdlist(ldap_inst)); + ISC_LIST_UNLINK(inst_fwdlist(ldap_inst), fwdr, link); + SAFE_MEM_PUT_PTR(ldap_inst->mctx, fwdr); } settings_set_free(&ldap_inst->global_settings); @@ -1479,7 +1497,11 @@ configure_zone_forwarders(ldap_entry_t *entry, ldap_instance_t *inst, isc_result_t lock_state = ISC_R_IGNORE; ldap_valuelist_t values; ldap_value_t *value; - isc_sockaddrlist_t addrs; +#if LIBDNS_VERSION_MAJOR < 140 + isc_sockaddrlist_t fwdrs; +#else /* LIBDNS_VERSION_MAJOR >= 140 */ + dns_forwarderlist_t fwdrs; +#endif isc_boolean_t is_global_config; isc_boolean_t fwdtbl_deletion_requested = ISC_TRUE; isc_boolean_t fwdtbl_update_requested = ISC_FALSE; @@ -1498,7 +1520,7 @@ configure_zone_forwarders(ldap_entry_t *entry, ldap_instance_t *inst, dns_fwdpolicy_t fwdpolicy = dns_fwdpolicy_first; REQUIRE(entry != NULL && inst != NULL && name != NULL); - ISC_LIST_INIT(addrs); + ISC_LIST_INIT(fwdrs); dns_fixedname_init(&foundname); if (dns_name_equal(name, dns_rootname)) { is_global_config = ISC_TRUE; @@ -1549,7 +1571,7 @@ configure_zone_forwarders(ldap_entry_t *entry, ldap_instance_t *inst, msg_forwarders_not_def); if (is_global_config) { ISC_LIST_INIT(values); - addrs = inst->orig_global_forwarders.addrs; + fwdrs = inst_fwdlist(inst); fwdpolicy = inst->orig_global_forwarders.fwdpolicy; } else { CLEANUP_WITH(ISC_R_DISABLED); @@ -1563,24 +1585,34 @@ configure_zone_forwarders(ldap_entry_t *entry, ldap_instance_t *inst, msg_forward_policy); for (value = HEAD(values); value != NULL; value = NEXT(value, link)) { - isc_sockaddr_t *addr = NULL; +#if LIBDNS_VERSION_MAJOR < 140 + isc_sockaddr_t *fwdr = NULL; +#else /* LIBDNS_VERSION_MAJOR >= 140 */ + dns_forwarder_t *fwdr = NULL; +#endif char forwarder_txt[ISC_SOCKADDR_FORMATSIZE]; - if (acl_parse_forwarder(value->value, inst->mctx, &addr) + if (acl_parse_forwarder(value->value, inst->mctx, &fwdr) != ISC_R_SUCCESS) { log_error("%s '%s': could not parse forwarder '%s'", msg_obj_type, dn, value->value); continue; } - ISC_LINK_INIT(addr, link); - ISC_LIST_APPEND(addrs, addr, link); - isc_sockaddr_format(addr, forwarder_txt, ISC_SOCKADDR_FORMATSIZE); + ISC_LINK_INIT(fwdr, link); + ISC_LIST_APPEND(fwdrs, fwdr, link); + isc_sockaddr_format( +#if LIBDNS_VERSION_MAJOR < 140 + fwdr, +#else /* LIBDNS_VERSION_MAJOR >= 140 */ + &fwdr->addr, +#endif + forwarder_txt, ISC_SOCKADDR_FORMATSIZE); log_debug(5, "%s '%s': adding forwarder '%s'", msg_obj_type, dn, forwarder_txt); } - if (fwdpolicy != dns_fwdpolicy_none && ISC_LIST_EMPTY(addrs)) { + if (fwdpolicy != dns_fwdpolicy_none && ISC_LIST_EMPTY(fwdrs)) { log_debug(5, "%s '%s': all idnsForwarders are invalid%s", msg_obj_type, dn, msg_use_global_fwds); CLEANUP_WITH(ISC_R_UNEXPECTEDTOKEN); @@ -1596,17 +1628,31 @@ configure_zone_forwarders(ldap_entry_t *entry, ldap_instance_t *inst, &old_setting); if (result == ISC_R_SUCCESS && (dns_name_equal(name, dns_fixedname_name(&foundname)) == ISC_TRUE)) { +#if LIBDNS_VERSION_MAJOR < 140 isc_sockaddr_t *s1, *s2; +#else /* LIBDNS_VERSION_MAJOR >= 140 */ + dns_forwarder_t *s1, *s2; +#endif if (fwdpolicy != old_setting->fwdpolicy) fwdtbl_update_requested = ISC_TRUE; /* Check address lists item by item. */ - for (s1 = ISC_LIST_HEAD(addrs), s2 = ISC_LIST_HEAD(old_setting->addrs); +#if LIBDNS_VERSION_MAJOR < 140 + for (s1 = ISC_LIST_HEAD(fwdrs), s2 = ISC_LIST_HEAD(old_setting->addrs); +#else /* LIBDNS_VERSION_MAJOR >= 140 */ + for (s1 = ISC_LIST_HEAD(fwdrs), s2 = ISC_LIST_HEAD(old_setting->fwdrs); +#endif s1 != NULL && s2 != NULL && !fwdtbl_update_requested; s1 = ISC_LIST_NEXT(s1, link), s2 = ISC_LIST_NEXT(s2, link)) - if (!isc_sockaddr_equal(s1, s2)) - fwdtbl_update_requested = ISC_TRUE; +#if LIBDNS_VERSION_MAJOR < 140 + if (!isc_sockaddr_equal(s1, s2)) { +#else /* LIBDNS_VERSION_MAJOR >= 140 */ + if (!isc_sockaddr_equal(&s1->addr, &s2->addr) || + s1->dscp != s2->dscp) { +#endif + fwdtbl_update_requested = ISC_TRUE; + } if (!fwdtbl_update_requested && ((s1 != NULL) || (s2 != NULL))) fwdtbl_update_requested = ISC_TRUE; @@ -1638,7 +1684,13 @@ configure_zone_forwarders(ldap_entry_t *entry, ldap_instance_t *inst, /* Something was changed - set forward table up. */ CHECK(delete_forwarding_table(inst, name, msg_obj_type, dn)); - result = dns_fwdtable_add(inst->view->fwdtable, name, &addrs, fwdpolicy); +#if LIBDNS_VERSION_MAJOR < 140 + result = dns_fwdtable_add(inst->view->fwdtable, name, &fwdrs, + fwdpolicy); +#else /* LIBDNS_VERSION_MAJOR >= 140 */ + result = dns_fwdtable_addfwd(inst->view->fwdtable, name, &fwdrs, + fwdpolicy); +#endif if (result != ISC_R_SUCCESS) log_error_r("%s '%s': forwarding table update failed", msg_obj_type, dn); @@ -1654,13 +1706,17 @@ configure_zone_forwarders(ldap_entry_t *entry, ldap_instance_t *inst, } cleanup: - if (ISC_LIST_HEAD(addrs) != - ISC_LIST_HEAD(inst->orig_global_forwarders.addrs)) { - while(!ISC_LIST_EMPTY(addrs)) { - isc_sockaddr_t *addr = NULL; - addr = ISC_LIST_HEAD(addrs); - ISC_LIST_UNLINK(addrs, addr, link); - SAFE_MEM_PUT_PTR(inst->mctx, addr); + if (ISC_LIST_HEAD(fwdrs) != + ISC_LIST_HEAD(inst_fwdlist(inst))) { + while(!ISC_LIST_EMPTY(fwdrs)) { +#if LIBDNS_VERSION_MAJOR < 140 + isc_sockaddr_t *fwdr = NULL; +#else /* LIBDNS_VERSION_MAJOR >= 140 */ + dns_forwarder_t *fwdr = NULL; +#endif + fwdr = ISC_LIST_HEAD(fwdrs); + ISC_LIST_UNLINK(fwdrs, fwdr, link); + SAFE_MEM_PUT_PTR(inst->mctx, fwdr); } } if (fwdtbl_deletion_requested) { -- 2.1.0
_______________________________________________ Freeipa-devel mailing list [email protected] https://www.redhat.com/mailman/listinfo/freeipa-devel
