From 719662bbb74940c3954a2ed0dde0a8d70b942b53 Mon Sep 17 00:00:00 2001 From: Alexander Bokovoy Date: Nov 05 2019 11:37:51 +0000 Subject: [PATCH 1/3] Remove use of isc/boolean.h With merge commit fa03f941027cdcccc060613f773e63701b5baa77, isc/boolean.h is removed from BIND9. --- diff --git a/src/acl.c b/src/acl.c index 0d475f0..9ec9f91 100644 --- a/src/acl.c +++ b/src/acl.c @@ -67,7 +67,7 @@ const enum_txt_assoc_t acl_type_txts[] = { } while (0) static isc_result_t ATTR_NONNULLS ATTR_CHECKRESULT -get_mode(const cfg_obj_t *obj, isc_boolean_t *value) +get_mode(const cfg_obj_t *obj, bool *value) { const char *str; @@ -82,8 +82,8 @@ get_mode(const cfg_obj_t *obj, isc_boolean_t *value) } str = cfg_obj_asstring(obj); - MATCH("grant", ISC_TRUE); - MATCH("deny", ISC_FALSE); + MATCH("grant", true); + MATCH("deny", false); log_bug("unsupported ACL mode '%s'", str); return ISC_R_NOTIMPLEMENTED; @@ -175,7 +175,7 @@ get_fixed_name(const cfg_obj_t *obj, const char *name, dns_fixedname_t *fname) dns_fixedname_init(fname); result = dns_name_fromtext(dns_fixedname_name(fname), &buf, - dns_rootname, ISC_FALSE, NULL); + dns_rootname, false, NULL); if (result != ISC_R_SUCCESS) log_error("'%s' is not a valid name", str); @@ -296,7 +296,7 @@ acl_configure_zone_ssutable(const char *policy_str, dns_zone_t *zone) for (el = cfg_list_first(policy); el != NULL; el = cfg_list_next(el)) { const cfg_obj_t *stmt; - isc_boolean_t grant; + bool grant; unsigned int match_type; dns_fixedname_t fname, fident; dns_rdatatype_t *types; diff --git a/src/empty_zones.c b/src/empty_zones.c index 5e5c73f..e9027d5 100644 --- a/src/empty_zones.c +++ b/src/empty_zones.c @@ -153,7 +153,7 @@ empty_zone_search_next(empty_zone_search_t *iter) { int order; unsigned int nlabels; dns_zone_t *zone = NULL; - isc_boolean_t isempty; + bool isempty; REQUIRE(iter != NULL); REQUIRE(iter->nextidx < sizeof(empty_zones)); @@ -184,12 +184,12 @@ empty_zone_search_next(empty_zone_search_t *iter) { isempty = zone_isempty(zone); else if (result == DNS_R_PARTIALMATCH || result == ISC_R_NOTFOUND) - isempty = ISC_FALSE; + isempty = false; else goto cleanup; if (zone != NULL) dns_zone_detach(&zone); - if (isempty == ISC_FALSE) + if (isempty == false) continue; ++iter->nextidx; CLEANUP_WITH(ISC_R_SUCCESS); @@ -299,10 +299,10 @@ cleanup: */ isc_result_t empty_zone_handle_conflicts(dns_name_t *name, dns_zt_t *zonetable, - isc_boolean_t warn_only) + bool warn_only) { isc_result_t result; - isc_boolean_t first = ISC_TRUE; + bool first = true; empty_zone_search_t eziter = {}; /* init with zeroes */ char name_char[DNS_NAME_FORMATSIZE]; char ezname_char[DNS_NAME_FORMATSIZE]; @@ -312,7 +312,7 @@ empty_zone_handle_conflicts(dns_name_t *name, dns_zt_t *zonetable, result = empty_zone_search_next(&eziter)) { dns_name_format(name, name_char, DNS_NAME_FORMATSIZE); - if (warn_only == ISC_TRUE) { + if (warn_only == true) { dns_name_format(&eziter.ezname, ezname_char, DNS_NAME_FORMATSIZE); log_warn("ignoring inherited 'forward first;' for zone " @@ -325,10 +325,10 @@ empty_zone_handle_conflicts(dns_name_t *name, dns_zt_t *zonetable, /* Shutdown automatic empty zone if it is present. */ result = empty_zone_unload(&eziter.ezname, zonetable); if (result == ISC_R_SUCCESS) { - if (first == ISC_TRUE) { + if (first == true) { log_info("shutting down automatic empty zones to " "enable forwarding for domain '%s'", name_char); - first = ISC_FALSE; + first = false; } } else if (result == DNS_R_DISALLOWED) { /* A normal (non-empty) zone exists: diff --git a/src/empty_zones.h b/src/empty_zones.h index 2712942..024904e 100644 --- a/src/empty_zones.h +++ b/src/empty_zones.h @@ -26,7 +26,7 @@ empty_zone_search_init(empty_zone_search_t *iter, dns_name_t *qname, isc_result_t empty_zone_handle_conflicts(dns_name_t *name, dns_zt_t *zonetable, - isc_boolean_t warn_only) ATTR_NONNULLS ATTR_CHECKRESULT; + bool warn_only) ATTR_NONNULLS ATTR_CHECKRESULT; /* Trigger to execute empty_zone_handle_conflicts() for dns_rootname. */ #define LDAPDB_EVENT_GLOBALFWD_HANDLEEZ (LDAPDB_EVENTCLASS + 5) @@ -34,7 +34,7 @@ empty_zone_handle_conflicts(dns_name_t *name, dns_zt_t *zonetable, typedef struct ldap_globalfwd_handleez ldap_globalfwd_handleez_t; struct ldap_globalfwd_handleez { ISC_EVENT_COMMON(ldap_globalfwd_handleez_t); - isc_boolean_t warn_only; + bool warn_only; }; void diff --git a/src/fwd.c b/src/fwd.c index f1ab60c..7ac381b 100644 --- a/src/fwd.c +++ b/src/fwd.c @@ -6,8 +6,6 @@ #include "config.h" -#include - #include #include @@ -308,15 +306,15 @@ fwdr_list_free(isc_mem_t *mctx, dns_forwarderlist_t *fwdrs) { * a) policy = none * b) (policy != none) && (non-empty list of forwarders) * - * @param[out] isexplicit ISC_TRUE if conditions for explicit configuration - * are met, ISC_FALSE otherwise + * @param[out] isexplicit true if conditions for explicit configuration + * are met, false otherwise * * @retval ISC_R_SUCCESS isexplicit is set appropriately * @retval other memory allocation or parsing errors etc. */ static isc_result_t fwd_setting_isexplicit(isc_mem_t *mctx, const settings_set_t *set, - isc_boolean_t *isexplicit) { + bool *isexplicit) { isc_result_t result; setting_t *setting = NULL; dns_fwdpolicy_t fwdpolicy; @@ -325,16 +323,16 @@ fwd_setting_isexplicit(isc_mem_t *mctx, const settings_set_t *set, REQUIRE(isexplicit != NULL); ISC_LIST_INIT(fwdrs); - CHECK(setting_find("forward_policy", set, ISC_FALSE, ISC_TRUE, &setting)); + CHECK(setting_find("forward_policy", set, false, true, &setting)); INSIST(get_enum_value(forwarder_policy_txts, setting->value.value_char, (int *)&fwdpolicy) == ISC_R_SUCCESS); if (fwdpolicy == dns_fwdpolicy_none) { - *isexplicit = ISC_TRUE; + *isexplicit = true; return ISC_R_SUCCESS; } setting = NULL; - CHECK(setting_find("forwarders", set, ISC_FALSE, ISC_TRUE, &setting)); + CHECK(setting_find("forwarders", set, false, true, &setting)); CHECK(fwd_parse_str(setting->value.value_char, mctx, &fwdrs)); cleanup: @@ -356,7 +354,7 @@ static isc_result_t fwd_setting_find_explicit(isc_mem_t *mctx, const settings_set_t *start_set, const settings_set_t **found) { isc_result_t result; - isc_boolean_t isexplicit; + bool isexplicit; REQUIRE(found != NULL && *found == NULL); @@ -365,7 +363,7 @@ fwd_setting_find_explicit(isc_mem_t *mctx, const settings_set_t *start_set, set = set->parent_set) { CHECK(fwd_setting_isexplicit(mctx, set, &isexplicit)); - if (isexplicit == ISC_TRUE) { + if (isexplicit == true) { *found = set; CLEANUP_WITH(ISC_R_SUCCESS); } @@ -436,7 +434,7 @@ fwd_parse_ldap(ldap_entry_t *entry, settings_set_t *set) { first = result; if (result != ISC_R_SUCCESS && result != ISC_R_IGNORE) goto cleanup; - result = setting_find("forward_policy", set, ISC_FALSE, ISC_TRUE, NULL); + result = setting_find("forward_policy", set, false, true, NULL); if (result == ISC_R_NOTFOUND) { log_debug(2, "defaulting to forward policy 'first' for " "%s", ldap_entry_logname(entry)); @@ -503,7 +501,7 @@ fwd_configure_zone(const settings_set_t *set, ldap_instance_t *inst, dns_view_t *view = NULL; isc_result_t lock_state = ISC_R_IGNORE; dns_forwarderlist_t fwdrs; - isc_boolean_t is_global_config; + bool is_global_config; dns_fixedname_t foundname; const char *msg_use_global_fwds; const char *msg_obj_type; @@ -515,7 +513,7 @@ fwd_configure_zone(const settings_set_t *set, ldap_instance_t *inst, dns_fwdpolicy_t fwdpolicy; const char *fwdpolicy_str = NULL; const char *forwarders_str = NULL; - isc_boolean_t isconfigured; + bool isconfigured; const settings_set_t *explicit_set = NULL; REQUIRE(inst != NULL && name != NULL); @@ -526,11 +524,11 @@ fwd_configure_zone(const settings_set_t *set, ldap_instance_t *inst, ISC_LIST_INIT(fwdrs); if (dns_name_equal(name, dns_rootname)) { - is_global_config = ISC_TRUE; + is_global_config = true; msg_obj_type = "global forwarding configuration"; msg_use_global_fwds = "; global forwarders will be disabled"; } else { - is_global_config = ISC_FALSE; + is_global_config = false; msg_obj_type = "zone"; msg_use_global_fwds = "; global forwarders will be used " "(if they are configured)"; @@ -543,10 +541,10 @@ fwd_configure_zone(const settings_set_t *set, ldap_instance_t *inst, * For all other zones (non-root) zones *do not* use recursive getter * and let BIND to handle inheritance in fwdtable itself. */ CHECK(fwd_setting_isexplicit(mctx, set, &isconfigured)); - if (isconfigured == ISC_FALSE && is_global_config == ISC_TRUE) { + if (isconfigured == false && is_global_config == true) { result = fwd_setting_find_explicit(mctx, set, &explicit_set); if (result == ISC_R_SUCCESS) { - isconfigured = ISC_TRUE; + isconfigured = true; if (set != explicit_set) { log_debug(5, "%s was inherited from %s", msg_obj_type, explicit_set->name); @@ -556,7 +554,7 @@ fwd_configure_zone(const settings_set_t *set, ldap_instance_t *inst, goto cleanup; } - if (isconfigured == ISC_TRUE) { + if (isconfigured == true) { CHECK(setting_get_str("forward_policy", set, &fwdpolicy_str)); result = get_enum_value(forwarder_policy_txts, fwdpolicy_str, (int *)&fwdpolicy); @@ -580,7 +578,7 @@ fwd_configure_zone(const settings_set_t *set, ldap_instance_t *inst, /* update forwarding table */ run_exclusive_enter(inst, &lock_state); CHECK(fwd_delete_table(view, name, msg_obj_type, set->name)); - if (isconfigured == ISC_TRUE) { + if (isconfigured == true) { CHECK(dns_fwdtable_addfwd(view->fwdtable, name, &fwdrs, fwdpolicy)); } @@ -592,7 +590,7 @@ fwd_configure_zone(const settings_set_t *set, ldap_instance_t *inst, dns_result_totext(result)); /* Handle collisions with automatic empty zones. */ - if (isconfigured == ISC_TRUE) + if (isconfigured == true) CHECK(empty_zone_handle_conflicts(name, view->zonetable, (fwdpolicy == dns_fwdpolicy_first))); @@ -634,7 +632,7 @@ isc_result_t fwd_reconfig_global(ldap_instance_t *inst) { isc_result_t result; settings_set_t *toplevel_settings = NULL; - isc_boolean_t root_zone_is_active = ISC_FALSE; + bool root_zone_is_active = false; /* we have to respect forwarding configuration for root zone */ result = zr_get_zone_settings(ldap_instance_getzr(inst), dns_rootname, @@ -646,7 +644,7 @@ fwd_reconfig_global(ldap_instance_t *inst) { else if (result != ISC_R_NOTFOUND) goto cleanup; - if (root_zone_is_active == ISC_FALSE) + if (root_zone_is_active == false) toplevel_settings = ldap_instance_getsettings_server(inst); CHECK(fwd_configure_zone(toplevel_settings, inst, dns_rootname)); diff --git a/src/fwd_register.c b/src/fwd_register.c index 7cc0c5a..06a4d92 100644 --- a/src/fwd_register.c +++ b/src/fwd_register.c @@ -101,7 +101,7 @@ fwdr_del_zone(fwd_register_t *fwdr, dns_name_t *name) RWLOCK(&fwdr->rwlock, isc_rwlocktype_write); - CHECK(dns_rbt_deletename(fwdr->rbt, name, ISC_FALSE)); + CHECK(dns_rbt_deletename(fwdr->rbt, name, false)); cleanup: RWUNLOCK(&fwdr->rwlock, isc_rwlocktype_write); diff --git a/src/ldap_convert.c b/src/ldap_convert.c index 6e24c81..853ad37 100644 --- a/src/ldap_convert.c +++ b/src/ldap_convert.c @@ -34,7 +34,7 @@ * @param[out] target Absolute DNS name derived from the first two idnsNames. * @param[out] origin Absolute DNS name derived from the last idnsName * component of DN, i.e. zone. Can be NULL. - * @param[out] iszone ISC_TRUE if DN points to zone object, ISC_FALSE otherwise. + * @param[out] iszone true if DN points to zone object, false otherwise. * * @code * Examples: @@ -53,7 +53,7 @@ */ isc_result_t dn_to_dnsname(isc_mem_t *mctx, const char *dn_str, dns_name_t *target, - dns_name_t *otarget, isc_boolean_t *iszone) + dns_name_t *otarget, bool *iszone) { LDAPDN dn = NULL; LDAPRDN rdn = NULL; @@ -130,20 +130,20 @@ dn_to_dnsname(isc_mem_t *mctx, const char *dn_str, dns_name_t *target, CLEANUP_WITH(ISC_R_UNEXPECTEDEND); } else if (idx == 1) { /* zone only */ if (iszone != NULL) - *iszone = ISC_TRUE; + *iszone = true; CHECK(dns_name_copy(dns_rootname, &origin, NULL)); CHECK(dns_name_fromtext(&name, &name_buf, dns_rootname, 0, NULL)); } else if (idx == 2) { /* owner and zone */ if (iszone != NULL) - *iszone = ISC_FALSE; + *iszone = false; CHECK(dns_name_fromtext(&origin, &origin_buf, dns_rootname, 0, NULL)); CHECK(dns_name_fromtext(&name, &name_buf, &origin, 0, NULL)); - if (dns_name_issubdomain(&name, &origin) == ISC_FALSE) { + if (dns_name_issubdomain(&name, &origin) == false) { log_error("out-of-zone data: first idnsName is not a " "subdomain of the other"); CLEANUP_WITH(DNS_R_BADOWNERNAME); - } else if (dns_name_equal(&name, &origin) == ISC_TRUE) { + } else if (dns_name_equal(&name, &origin) == true) { log_error("attempt to redefine zone apex: first " "idnsName equals to zone name"); CLEANUP_WITH(DNS_R_BADOWNERNAME); @@ -185,12 +185,12 @@ cleanup: * @param[in] prefix Prefix for error messages, usually a function name. * @param[in] dn * @param[in] dniszone Boolean returned by dn_to_dnsname for given DN. - * @param[in] classiszone ISC_TRUE if DN should be a zone, ISC_FALSE otherwise. + * @param[in] classiszone true if DN should be a zone, false otherwise. * @retval ISC_R_SUCCESS or ISC_R_UNEXPECTED if values do not match. */ isc_result_t dn_want_zone(const char * const prefix, const char * const dn, - isc_boolean_t dniszone, isc_boolean_t classiszone) { + bool dniszone, bool classiszone) { if (dniszone != classiszone) { log_error("%s: object '%s' does%s have a zone object class " "but DN format suggests that it is%s a zone", @@ -423,12 +423,12 @@ ldap_attribute_to_rdatatype(const char *ldap_attribute, dns_rdatatype_t *rdtype) * @param[in] rdtype * @param[out] target Output buffer with \0 terminated attribute name. * @param[in] size Target size. - * @param[in] unknown ISC_TRUE = use generic syntax "UnknownRecord;TYPE65333", - * ISC_FALSE = use type-specific mnemonic like "ARecord" + * @param[in] unknown true = use generic syntax "UnknownRecord;TYPE65333", + * false = use type-specific mnemonic like "ARecord" */ isc_result_t rdatatype_to_ldap_attribute(dns_rdatatype_t rdtype, char *target, - unsigned int size, isc_boolean_t unknown) + unsigned int size, bool unknown) { isc_result_t result; char rdtype_str[DNS_RDATATYPE_FORMATSIZE]; diff --git a/src/ldap_convert.h b/src/ldap_convert.h index fcd575b..0c91ca0 100644 --- a/src/ldap_convert.h +++ b/src/ldap_convert.h @@ -28,11 +28,11 @@ */ isc_result_t dn_to_dnsname(isc_mem_t *mctx, const char *dn, dns_name_t *target, dns_name_t *origin, - isc_boolean_t *iszone) + bool *iszone) ATTR_NONNULL(1, 2, 3) ATTR_CHECKRESULT; isc_result_t dn_want_zone(const char * const prefix, const char * const dn, - isc_boolean_t dniszone, isc_boolean_t classiszone) + bool dniszone, bool classiszone) ATTR_NONNULLS ATTR_CHECKRESULT; isc_result_t dnsname_to_dn(zone_register_t *zr, dns_name_t *name, dns_name_t *zone, @@ -43,7 +43,7 @@ isc_result_t ldap_attribute_to_rdatatype(const char *ldap_record, isc_result_t rdatatype_to_ldap_attribute(dns_rdatatype_t rdtype, char *target, - unsigned int size, isc_boolean_t unknown) + unsigned int size, bool unknown) ATTR_NONNULLS ATTR_CHECKRESULT; isc_result_t diff --git a/src/ldap_driver.c b/src/ldap_driver.c index 38673b0..7caee83 100644 --- a/src/ldap_driver.c +++ b/src/ldap_driver.c @@ -141,7 +141,7 @@ free_ldapdb(ldapdb_t *ldapdb) dns_masterformat_text); log_info("dump to '%s' finished: %s", str_buf(file_name), isc_result_totext(result)); - dns_db_closeversion(ldapdb->rbtdb, &version, ISC_FALSE); + dns_db_closeversion(ldapdb->rbtdb, &version, false); cleanup: if (result != ISC_R_SUCCESS) { @@ -267,7 +267,7 @@ currentversion(dns_db_t *db, dns_dbversion_t **versionp) cleanup: if (newversion != NULL) - dns_db_closeversion(ldapdb, &newversion, ISC_TRUE); + dns_db_closeversion(ldapdb, &newversion, true); @endverbatim */ static isc_result_t @@ -307,7 +307,7 @@ attachversion(dns_db_t *db, dns_dbversion_t *source, * @see newversion for related warnings and examples. */ static void -closeversion(dns_db_t *db, dns_dbversion_t **versionp, isc_boolean_t commit) +closeversion(dns_db_t *db, dns_dbversion_t **versionp, bool commit) { ldapdb_t *ldapdb = (ldapdb_t *)db; dns_dbversion_t *closed_version = *versionp; @@ -322,7 +322,7 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp, isc_boolean_t commit) } static isc_result_t -findnode(dns_db_t *db, dns_name_t *name, isc_boolean_t create, +findnode(dns_db_t *db, dns_name_t *name, bool create, dns_dbnode_t **nodep) { ldapdb_t *ldapdb = (ldapdb_t *) db; @@ -467,7 +467,7 @@ cleanup: static isc_result_t node_isempty(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, - isc_stdtime_t now, isc_boolean_t *isempty) { + isc_stdtime_t now, bool *isempty) { dns_rdatasetiter_t *rds_iter = NULL; dns_fixedname_t fname; char buff[DNS_NAME_FORMATSIZE]; @@ -479,14 +479,14 @@ node_isempty(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, result = dns_db_allrdatasets(db, node, version, now, &rds_iter); if (result == ISC_R_NOTFOUND) { - *isempty = ISC_TRUE; + *isempty = true; } else if (result == ISC_R_SUCCESS) { result = dns_rdatasetiter_first(rds_iter); if (result == ISC_R_NOMORE) { - *isempty = ISC_TRUE; + *isempty = true; result = ISC_R_SUCCESS; } else if (result == ISC_R_SUCCESS) { - *isempty = ISC_FALSE; + *isempty = false; result = ISC_R_SUCCESS; } else if (result != ISC_R_SUCCESS) { dns_name_format(dns_fixedname_name(&fname), @@ -516,7 +516,7 @@ subtractrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, dns_fixedname_t fname; dns_name_t *zname = NULL; dns_rdatalist_t *rdlist = NULL; - isc_boolean_t empty_node = ISC_FALSE; + bool empty_node = false; isc_result_t substract_result; isc_result_t result; @@ -561,7 +561,7 @@ deleterdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, ldapdb_t *ldapdb = (ldapdb_t *) db; dns_fixedname_t fname; dns_name_t *zname = NULL; - isc_boolean_t empty_node; + bool empty_node; isc_result_t result; REQUIRE(VALID_LDAPDB(ldapdb)); @@ -580,7 +580,7 @@ deleterdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, CHECK(node_isempty(ldapdb->rbtdb, node, version, 0, &empty_node)); CHECK(ldapdb_name_fromnode(node, dns_fixedname_name(&fname))); - if (empty_node == ISC_TRUE) { + if (empty_node == true) { CHECK(remove_entry_from_ldap(dns_fixedname_name(&fname), zname, ldapdb->ldap_inst)); } else { @@ -592,7 +592,7 @@ cleanup: return result; } -static isc_boolean_t +static bool issecure(dns_db_t *db) { ldapdb_t *ldapdb = (ldapdb_t *) db; @@ -618,16 +618,16 @@ nodecount(dns_db_t *db) * * !!! This could be required for optimizations (like on-disk cache). */ -static isc_boolean_t +static bool ispersistent(dns_db_t *db) { UNUSED(db); - return ISC_TRUE; + return true; } static void -overmem(dns_db_t *db, isc_boolean_t overmem) +overmem(dns_db_t *db, bool overmem) { ldapdb_t *ldapdb = (ldapdb_t *) db; @@ -683,7 +683,7 @@ getnsec3parameters(dns_db_t *db, dns_dbversion_t *version, } static isc_result_t -findnsec3node(dns_db_t *db, dns_name_t *name, isc_boolean_t create, +findnsec3node(dns_db_t *db, dns_name_t *name, bool create, dns_dbnode_t **nodep) { ldapdb_t *ldapdb = (ldapdb_t *) db; @@ -724,7 +724,7 @@ resigned(dns_db_t *db, dns_rdataset_t *rdataset, dns_db_resigned(ldapdb->rbtdb, rdataset, version); } -static isc_boolean_t +static bool isdnssec(dns_db_t *db) { ldapdb_t *ldapdb = (ldapdb_t *) db; @@ -766,7 +766,7 @@ rpz_ready(dns_db_t *db) static isc_result_t findnodeext(dns_db_t *db, dns_name_t *name, - isc_boolean_t create, dns_clientinfomethods_t *methods, + bool create, dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo, dns_dbnode_t **nodep) { ldapdb_t *ldapdb = (ldapdb_t *) db; @@ -950,7 +950,7 @@ ldapdb_create(isc_mem_t *mctx, dns_name_t *name, dns_dbtype_t type, { ldapdb_t *ldapdb = NULL; isc_result_t result; - isc_boolean_t lock_ready = ISC_FALSE; + bool lock_ready = false; /* Database instance name. */ REQUIRE(type == LDAP_DB_TYPE); @@ -963,7 +963,7 @@ ldapdb_create(isc_mem_t *mctx, dns_name_t *name, dns_dbtype_t type, isc_mem_attach(mctx, &ldapdb->common.mctx); CHECK(isc_mutex_init(&ldapdb->newversion_lock)); - lock_ready = ISC_TRUE; + lock_ready = true; dns_name_init(&ldapdb->common.origin, NULL); isc_ondestroy_init(&ldapdb->common.ondest); @@ -988,7 +988,7 @@ ldapdb_create(isc_mem_t *mctx, dns_name_t *name, dns_dbtype_t type, cleanup: if (ldapdb != NULL) { - if (lock_ready == ISC_TRUE) + if (lock_ready == true) RUNTIME_CHECK(isc_mutex_destroy(&ldapdb->newversion_lock) == ISC_R_SUCCESS); if (dns_name_dynamic(&ldapdb->common.origin)) diff --git a/src/ldap_entry.c b/src/ldap_entry.c index 00a7e89..1698fd3 100644 --- a/src/ldap_entry.c +++ b/src/ldap_entry.c @@ -190,8 +190,8 @@ ldap_entry_parse(isc_mem_t *mctx, LDAP *ld, LDAPMessage *ldap_entry, char *attribute; BerElement *ber = NULL; ldap_entry_t *entry = NULL; - isc_boolean_t has_zone_dn; - isc_boolean_t has_zone_class; + bool has_zone_dn; + bool has_zone_class; REQUIRE(ld != NULL); REQUIRE(ldap_entry != NULL); @@ -235,9 +235,9 @@ ldap_entry_parse(isc_mem_t *mctx, LDAP *ld, LDAPMessage *ldap_entry, CHECK(dn_to_dnsname(mctx, entry->dn, &entry->fqdn, &entry->zone_name, &has_zone_dn)); else - has_zone_dn = ISC_FALSE; - has_zone_class = ISC_TF(entry->class & (LDAP_ENTRYCLASS_MASTER - | LDAP_ENTRYCLASS_FORWARD)); + has_zone_dn = false; + has_zone_class = entry->class & (LDAP_ENTRYCLASS_MASTER + | LDAP_ENTRYCLASS_FORWARD); CHECK(dn_want_zone(__func__, entry->dn, has_zone_dn, has_zone_class)); diff --git a/src/ldap_helper.c b/src/ldap_helper.c index 7f70ee3..127cfcd 100644 --- a/src/ldap_helper.c +++ b/src/ldap_helper.c @@ -151,7 +151,7 @@ struct ldap_instance { isc_task_t *task; isc_thread_t watcher; - isc_boolean_t exiting; + bool exiting; /* Non-zero if this instance is 'tainted' by an unrecoverable problem. */ isc_refcount_t errors; @@ -329,28 +329,28 @@ ldap_parse_rrentry(isc_mem_t *mctx, ldap_entry_t *entry, dns_name_t *origin, ldapdb_rdatalist_t *rdatalist) ATTR_NONNULLS ATTR_CHECKRESULT; static isc_result_t ldap_connect(ldap_instance_t *ldap_inst, - ldap_connection_t *ldap_conn, isc_boolean_t force) ATTR_NONNULLS ATTR_CHECKRESULT; + ldap_connection_t *ldap_conn, bool force) ATTR_NONNULLS ATTR_CHECKRESULT; static isc_result_t ldap_reconnect(ldap_instance_t *ldap_inst, - ldap_connection_t *ldap_conn, isc_boolean_t force) ATTR_NONNULLS ATTR_CHECKRESULT; + ldap_connection_t *ldap_conn, bool force) ATTR_NONNULLS ATTR_CHECKRESULT; static isc_result_t handle_connection_error(ldap_instance_t *ldap_inst, - ldap_connection_t *ldap_conn, isc_boolean_t force) ATTR_NONNULLS; + ldap_connection_t *ldap_conn, bool force) ATTR_NONNULLS; /* Functions for writing to LDAP. */ static isc_result_t ldap_rdttl_to_ldapmod(isc_mem_t *mctx, dns_rdatalist_t *rdlist, LDAPMod **changep) ATTR_NONNULLS ATTR_CHECKRESULT; static isc_result_t ldap_rdatalist_to_ldapmod(isc_mem_t *mctx, dns_rdatalist_t *rdlist, LDAPMod **changep, int mod_op, - isc_boolean_t unknown) ATTR_NONNULLS ATTR_CHECKRESULT; + bool unknown) ATTR_NONNULLS ATTR_CHECKRESULT; static isc_result_t ldap_rdata_to_char_array(isc_mem_t *mctx, dns_rdata_t *rdata_head, - isc_boolean_t unknown, + bool unknown, char ***valsp) ATTR_NONNULLS ATTR_CHECKRESULT; static void free_char_array(isc_mem_t *mctx, char ***valsp) ATTR_NONNULLS; static isc_result_t modify_ldap_common(dns_name_t *owner, dns_name_t *zone, ldap_instance_t *ldap_inst, - dns_rdatalist_t *rdlist, int mod_op, isc_boolean_t delete_node) ATTR_NONNULLS ATTR_CHECKRESULT; + dns_rdatalist_t *rdlist, int mod_op, bool delete_node) ATTR_NONNULLS ATTR_CHECKRESULT; /* Functions for maintaining pool of LDAP connections */ static isc_result_t ldap_pool_create(isc_mem_t *mctx, unsigned int connections, @@ -385,7 +385,7 @@ validate_local_instance_settings(ldap_instance_t *inst, settings_set_t *set) { const char *bind_dn = NULL; const char *password = NULL; const char *dir_name = NULL; - isc_boolean_t dir_default; + bool dir_default; ld_string_t *buff = NULL; char print_buff[PRINT_BUFF_SIZE]; const char *auth_method_str = NULL; @@ -400,7 +400,7 @@ validate_local_instance_settings(ldap_instance_t *inst, settings_set_t *set) { CHECK(str_new(inst->mctx, &buff)); CHECK(setting_get_str("directory", inst->local_settings, &dir_name)); dir_default = (strlen(dir_name) == 0); - if (dir_default == ISC_TRUE) { + if (dir_default == true) { CHECK(str_cat_char(buff, "dyndb-ldap/")); CHECK(str_cat_char(buff, inst->db_name)); } else @@ -513,7 +513,7 @@ validate_local_instance_settings(ldap_instance_t *inst, settings_set_t *set) { "are untested; expect problems"); } - if (settings_set_isfilled(set) != ISC_TRUE) + if (settings_set_isfilled(set) != true) result = ISC_R_FAILURE; cleanup: @@ -622,7 +622,7 @@ new_ldap_instance(isc_mem_t *mctx, const char *db_name, const char *parameters, CHECK(validate_local_instance_settings(ldap_inst, ldap_inst->local_settings)); - if (settings_set_isfilled(ldap_inst->global_settings) != ISC_TRUE) + if (settings_set_isfilled(ldap_inst->global_settings) != true) CLEANUP_WITH(ISC_R_FAILURE); /* zero-length server_id means undefined value */ @@ -700,7 +700,7 @@ ldap_syncrepl_watcher_shutdown(ldap_instance_t *ldap_inst) { REQUIRE(ldap_inst != NULL); - ldap_inst->exiting = ISC_TRUE; + ldap_inst->exiting = true; /* * Wake up the watcher thread. This might look like a hack * but isc_thread_t is actually pthread_t and libisc don't @@ -821,7 +821,7 @@ destroy_ldap_connection(ldap_connection_t **ldap_connp) static isc_result_t ATTR_NONNULLS cleanup_zone_files(dns_zone_t *zone) { isc_result_t result; - isc_boolean_t failure = ISC_FALSE; + bool failure = false; const char *filename = NULL; dns_zone_t *raw = NULL; int namelen; @@ -853,11 +853,11 @@ cleanup_zone_files(dns_zone_t *zone) { cleanup: failure = failure || (result != ISC_R_SUCCESS); - if (failure == ISC_TRUE) + if (failure == true) dns_zone_log(zone, ISC_LOG_ERROR, "unable to remove files, expect problems"); - if (failure == ISC_TRUE && result == ISC_R_SUCCESS) + if (failure == true && result == ISC_R_SUCCESS) result = ISC_R_FAILURE; return result; @@ -912,7 +912,7 @@ zone_unload_ifempty(dns_view_t *view, dns_name_t *name) { CHECK(dns_view_findzone(view, name, &zone)); - if (zone_isempty(zone) == ISC_TRUE) { + if (zone_isempty(zone) == true) { dns_name_format(name, zone_name, DNS_NAME_FORMATSIZE); result = delete_bind_zone(view->zonetable, &zone); if (result != ISC_R_SUCCESS) @@ -933,7 +933,7 @@ cleanup: static isc_result_t ATTR_NONNULLS ATTR_CHECKRESULT configure_paths(isc_mem_t *mctx, ldap_instance_t *inst, dns_zone_t *zone, - isc_boolean_t issecure) { + bool issecure) { isc_result_t result; ld_string_t *file_name = NULL; ld_string_t *key_dir = NULL; @@ -942,7 +942,7 @@ configure_paths(isc_mem_t *mctx, ldap_instance_t *inst, dns_zone_t *zone, dns_zone_getorigin(zone), (issecure ? "signed" : "raw"), &file_name)); CHECK(dns_zone_setfile(zone, str_buf(file_name))); - if (issecure == ISC_TRUE) { + if (issecure == true) { CHECK(zr_get_zone_path(mctx, ldap_instance_getsettings_local(inst), dns_zone_getorigin(zone), "keys/", @@ -965,7 +965,7 @@ cleanup: static isc_result_t ATTR_NONNULLS ATTR_CHECKRESULT create_zone(ldap_instance_t * const inst, const char * const dn, dns_name_t * const name, dns_db_t * const ldapdb, - const isc_boolean_t want_secure, dns_zone_t ** const rawp, + const bool want_secure, dns_zone_t ** const rawp, dns_zone_t ** const securep) { isc_result_t result; @@ -992,9 +992,9 @@ create_zone(ldap_instance_t * const inst, const char * const dn, /* dns_zone_setview(raw, view); */ CHECK(dns_zone_setdbtype(raw, sizeof(ldap_argv)/sizeof(ldap_argv[0]), ldap_argv)); - CHECK(configure_paths(inst->mctx, inst, raw, ISC_FALSE)); + CHECK(configure_paths(inst->mctx, inst, raw, false)); - if (want_secure == ISC_FALSE) { + if (want_secure == false) { CHECK(dns_zonemgr_managezone(inst->zmgr, raw)); CHECK(cleanup_zone_files(raw)); } else { @@ -1006,8 +1006,8 @@ create_zone(ldap_instance_t * const inst, const char * const dn, CHECK(dns_zone_setdbtype(secure, 1, rbt_argv)); CHECK(dns_zonemgr_managezone(inst->zmgr, secure)); CHECK(dns_zone_link(secure, raw)); - dns_zone_rekey(secure, ISC_TRUE); - CHECK(configure_paths(inst->mctx, inst, secure, ISC_TRUE)); + dns_zone_rekey(secure, true); + CHECK(configure_paths(inst->mctx, inst, secure, true)); CHECK(cleanup_zone_files(secure)); } @@ -1049,9 +1049,9 @@ cleanup: * @warning Never call this on raw part of in-line secure zone. */ static isc_result_t ATTR_NONNULLS ATTR_CHECKRESULT -load_zone(dns_zone_t *zone, isc_boolean_t log) { +load_zone(dns_zone_t *zone, bool log) { isc_result_t result; - isc_boolean_t zone_dynamic; + bool zone_dynamic; isc_uint32_t serial; dns_zone_t *raw = NULL; @@ -1068,16 +1068,16 @@ load_zone(dns_zone_t *zone, isc_boolean_t log) { } CHECK(dns_zone_getserial2(raw, &serial)); - if (log == ISC_TRUE) + if (log == true) dns_zone_log(raw, ISC_LOG_INFO, "loaded serial %u", serial); if (zone != NULL) { result = dns_zone_getserial2(zone, &serial); - if (result == ISC_R_SUCCESS && log == ISC_TRUE) + if (result == ISC_R_SUCCESS && log == true) dns_zone_log(zone, ISC_LOG_INFO, "loaded serial %u", serial); /* in-line secure zone is loaded asynchonously in background */ else if (result == DNS_R_NOTLOADED) { - if (log == ISC_TRUE) + if (log == true) dns_zone_log(zone, ISC_LOG_INFO, "signing in progress"); result = ISC_R_SUCCESS; @@ -1101,7 +1101,7 @@ static isc_result_t ATTR_NONNULLS ATTR_CHECKRESULT publish_zone(isc_task_t *task, ldap_instance_t *inst, dns_zone_t *zone) { isc_result_t result; - isc_boolean_t freeze = ISC_FALSE; + bool freeze = false; dns_zone_t *zone_in_view = NULL; dns_view_t *view_in_zone = NULL; isc_result_t lock_state = ISC_R_IGNORE; @@ -1141,7 +1141,7 @@ publish_zone(isc_task_t *task, ldap_instance_t *inst, dns_zone_t *zone) run_exclusive_enter(inst, &lock_state); if (inst->view->frozen) { - freeze = ISC_TRUE; + freeze = true; dns_view_thaw(inst->view); } @@ -1189,7 +1189,7 @@ activate_zone(isc_task_t *task, ldap_instance_t *inst, dns_name_t *name) { goto cleanup; } - CHECK(load_zone(toview, ISC_TRUE)); + CHECK(load_zone(toview, true)); if (secure != NULL) { CHECK(zr_get_zone_settings(inst->zone_register, name, &zone_settings)); @@ -1218,7 +1218,7 @@ activate_zones(isc_task_t *task, ldap_instance_t *inst) { unsigned int total_cnt = 0; unsigned int active_cnt = 0; settings_set_t *settings; - isc_boolean_t active; + bool active; INIT_BUFFERED_NAME(name); for(result = zr_rbt_iter_init(inst->zone_register, &iter, &name); @@ -1231,7 +1231,7 @@ activate_zones(isc_task_t *task, ldap_instance_t *inst) { INSIST(result == ISC_R_SUCCESS); ++total_cnt; - if (active == ISC_TRUE) { + if (active == true) { ++active_cnt; result = activate_zone(task, inst, &name); if (result == ISC_R_SUCCESS) @@ -1338,12 +1338,12 @@ configure_zone_ssutable(dns_zone_t *zone, const char *update_str) /* Delete zone by dns zone name */ isc_result_t -ldap_delete_zone2(ldap_instance_t *inst, dns_name_t *name, isc_boolean_t lock) +ldap_delete_zone2(ldap_instance_t *inst, dns_name_t *name, bool lock) { isc_result_t result; isc_result_t isforward = ISC_R_NOTFOUND; isc_result_t lock_state = ISC_R_IGNORE; - isc_boolean_t freeze = ISC_FALSE; + bool freeze = false; dns_zone_t *raw = NULL; dns_zone_t *secure = NULL; dns_zone_t *foundzone = NULL; @@ -1380,7 +1380,7 @@ ldap_delete_zone2(ldap_instance_t *inst, dns_name_t *name, isc_boolean_t lock) if (lock) { dns_view_thaw(inst->view); - freeze = ISC_TRUE; + freeze = true; } } /* else: zone wasn't in a view */ @@ -1414,13 +1414,13 @@ unpublish_zone(ldap_instance_t *inst, dns_name_t *name, const char *logname) { dns_zone_t *raw = NULL; dns_zone_t *secure = NULL; dns_zone_t *zone_in_view = NULL; - isc_boolean_t freeze = ISC_FALSE; + bool freeze = false; CHECK(zr_get_zone_ptr(inst->zone_register, name, &raw, &secure)); run_exclusive_enter(inst, &lock_state); if (inst->view->frozen) { - freeze = ISC_TRUE; + freeze = true; dns_view_thaw(inst->view); } CHECK(dns_view_findzone(inst->view, name, &zone_in_view)); @@ -1537,7 +1537,7 @@ ldap_parse_fwd_zoneentry(ldap_entry_t *entry, ldap_instance_t *inst) if (HEAD(values) != NULL && strcasecmp(HEAD(values)->value, "TRUE") != 0) { /* Zone is not active */ - result = ldap_delete_zone2(inst, &entry->fqdn, ISC_TRUE); + result = ldap_delete_zone2(inst, &entry->fqdn, true); goto cleanup; } @@ -1621,14 +1621,14 @@ cleanup: * @param[out] soa_latest Pointer to last added SOA RR from tuple list. * Result can be NULL if there is no added SOA RR * in the tuple list. - * @param[out] data_changed ISC_TRUE if any data other than SOA serial were - * changed. ISC_FALSE if nothing (except SOA + * @param[out] data_changed true if any data other than SOA serial were + * changed. false if nothing (except SOA * serial) was changed. * */ static isc_result_t ATTR_NONNULLS ATTR_CHECKRESULT diff_analyze_serial(dns_diff_t *diff, dns_difftuple_t **soa_latest, - isc_boolean_t *data_changed) { + bool *data_changed) { dns_difftuple_t *t = NULL; dns_rdata_t *del_soa = NULL; /* last seen SOA with op == DEL */ dns_difftuple_t *tmp_tuple = NULL; /* tuple used for SOA comparison */ @@ -1639,13 +1639,13 @@ diff_analyze_serial(dns_diff_t *diff, dns_difftuple_t **soa_latest, REQUIRE(soa_latest != NULL && *soa_latest == NULL); REQUIRE(data_changed != NULL); - *data_changed = ISC_FALSE; + *data_changed = false; for (t = HEAD(diff->tuples); t != NULL; t = NEXT(t, link)) { INSIST(tmp_tuple == NULL); if (t->rdata.type != dns_rdatatype_soa) - *data_changed = ISC_TRUE; + *data_changed = true; else { /* SOA is always special case */ if (t->op == DNS_DIFFOP_DEL || t->op == DNS_DIFFOP_DELRESIGN) { @@ -1660,8 +1660,8 @@ diff_analyze_serial(dns_diff_t *diff, dns_difftuple_t **soa_latest, /* we are adding SOA without preceding delete * -> we are initializing new empty zone */ if (del_soa == NULL) { - *data_changed = ISC_TRUE; - } else if (*data_changed == ISC_FALSE) { + *data_changed = true; + } else if (*data_changed == false) { /* detect if fields other than serial * were changed (compute only if necessary) */ CHECK(dns_difftuple_copy(t, &tmp_tuple)); @@ -1669,7 +1669,7 @@ diff_analyze_serial(dns_diff_t *diff, dns_difftuple_t **soa_latest, &tmp_tuple->rdata); ret = dns_rdata_compare(del_soa, &tmp_tuple->rdata); - *data_changed = ISC_TF(ret != 0); + *data_changed = ret != 0; } if (tmp_tuple != NULL) dns_difftuple_free(&tmp_tuple); @@ -1719,7 +1719,7 @@ ldap_replace_serial(ldap_instance_t *inst, dns_name_t *zone, change.mod_values = values; CHECK(isc_string_printf(serial_char, MAX_SERIAL_LENGTH, "%u", serial)); - CHECK(ldap_modify_do(inst, str_buf(dn), changep, ISC_FALSE)); + CHECK(ldap_modify_do(inst, str_buf(dn), changep, false)); cleanup: str_destroy(&dn); @@ -1754,7 +1754,7 @@ zone_master_reconfigure_nsec3param(settings_set_t *zone_settings, CHECK(dns_zone_setnsec3param(secure, nsec3p_rr.hash, nsec3p_rr.flags, nsec3p_rr.iterations, nsec3p_rr.salt_length, nsec3p_rr.salt, - ISC_TRUE)); + true)); cleanup: if (nsec3p_rdata != NULL) { @@ -1778,7 +1778,7 @@ zone_master_reconfigure(ldap_entry_t *entry, settings_set_t *zone_settings, isc_result_t result; ldap_valuelist_t values; isc_mem_t *mctx = NULL; - isc_boolean_t ssu_changed; + bool ssu_changed; dns_zone_t *inview = NULL; REQUIRE(entry != NULL); @@ -1817,7 +1817,7 @@ zone_master_reconfigure(ldap_entry_t *entry, settings_set_t *zone_settings, goto cleanup; if (result == ISC_R_SUCCESS || ssu_changed) { - isc_boolean_t ssu_enabled; + bool ssu_enabled; const char *ssu_policy = NULL; CHECK(setting_get_bool("dyn_update", zone_settings, &ssu_enabled)); @@ -1886,7 +1886,7 @@ zone_master_reconfigure(ldap_entry_t *entry, settings_set_t *zone_settings, dns_zone_setprivatetype(secure, 65534); /* update-check-ksk */ - dns_zone_setoption(secure, DNS_ZONEOPT_UPDATECHECKKSK, ISC_TRUE); + dns_zone_setoption(secure, DNS_ZONEOPT_UPDATECHECKKSK, true); /* dnssec-loadkeys-interval */ CHECK(dns_zone_setrefreshkeyinterval(secure, 60)); @@ -1904,8 +1904,8 @@ zone_master_reconfigure(ldap_entry_t *entry, settings_set_t *zone_settings, goto cleanup; /* auto-dnssec = maintain */ - dns_zone_setkeyopt(secure, DNS_ZONEKEY_ALLOW, ISC_TRUE); - dns_zone_setkeyopt(secure, DNS_ZONEKEY_MAINTAIN, ISC_TRUE); + dns_zone_setkeyopt(secure, DNS_ZONEKEY_ALLOW, true); + dns_zone_setkeyopt(secure, DNS_ZONEKEY_MAINTAIN, true); } cleanup: @@ -1923,7 +1923,7 @@ cleanup: * @param[out] diff Initialized diff. It will be filled with differences * between RBTDB and LDAP object + SOA serial update. * @param[out] new_serial SOA serial after update; - * valid if ldap_writeback = ISC_TRUE. + * valid if ldap_writeback = true. * @param[out] ldap_writeback SOA serial was updated. * @param[out] data_changed Other data were updated. * @@ -1931,14 +1931,14 @@ cleanup: static isc_result_t ATTR_NONNULLS ATTR_CHECKRESULT zone_sync_apex(const ldap_instance_t * const inst, ldap_entry_t * const entry, dns_name_t name, - const sync_state_t sync_state, const isc_boolean_t new_zone, + const sync_state_t sync_state, const bool new_zone, dns_db_t * const ldapdb, dns_db_t * const rbtdb, dns_dbversion_t * const version, const settings_set_t * const zone_settings, dns_diff_t * const diff, isc_uint32_t * const new_serial, - isc_boolean_t * const ldap_writeback, - isc_boolean_t * const data_changed) { + bool * const ldap_writeback, + bool * const data_changed) { isc_result_t result; ldapdb_rdatalist_t rdatalist; dns_rdatasetiter_t *rbt_rds_iterator = NULL; @@ -1951,7 +1951,7 @@ zone_sync_apex(const ldap_instance_t * const inst, REQUIRE(ldap_writeback != NULL); INIT_LIST(rdatalist); - *ldap_writeback = ISC_FALSE; /* GCC */ + *ldap_writeback = false; /* GCC */ CHECK(ldap_parse_rrentry(inst->mctx, entry, &name, zone_settings, &rdatalist)); @@ -1967,37 +1967,37 @@ zone_sync_apex(const ldap_instance_t * const inst, goto cleanup; /* New zone doesn't have serial defined yet. */ - if (new_zone != ISC_TRUE) + if (new_zone != true) CHECK(dns_db_getsoaserial(rbtdb, version, &curr_serial)); /* Detect if SOA serial is affected by the update or not. * Always bump serial in case of re-synchronization. */ CHECK(diff_analyze_serial(diff, &soa_tuple, data_changed)); - if (new_zone == ISC_TRUE || *data_changed == ISC_TRUE || + if (new_zone == true || *data_changed == true || sync_state != sync_finished) { if (soa_tuple == NULL) { /* The diff doesn't contain new SOA serial * => generate new serial and write it back to LDAP. */ - *ldap_writeback = ISC_TRUE; + *ldap_writeback = true; CHECK(zone_soaserial_addtuple(inst->mctx, ldapdb, version, diff, new_serial)); - } else if (new_zone == ISC_TRUE || sync_state != sync_finished || + } else if (new_zone == true || sync_state != sync_finished || isc_serial_le(dns_soa_getserial(&soa_tuple->rdata), curr_serial)) { /* The diff tries to send SOA serial back! * => generate new serial and write it back to LDAP. * Force serial update if we are adding a new zone. */ - *ldap_writeback = ISC_TRUE; + *ldap_writeback = true; CHECK(zone_soaserial_updatetuple(dns_updatemethod_unixtime, soa_tuple, new_serial)); } else { /* The diff contains new serial already * => do nothing. */ - *ldap_writeback = ISC_FALSE; + *ldap_writeback = false; } - } else {/* if (data_changed == ISC_FALSE) */ - *ldap_writeback = ISC_FALSE; + } else {/* if (data_changed == false) */ + *ldap_writeback = false; if (soa_tuple == NULL) { /* The diff is empty => do nothing. */ INSIST(EMPTY(diff->tuples)); @@ -2039,7 +2039,7 @@ zone_security_change(ldap_entry_t * const entry, dns_name_t * const name, * in period where old zone was deleted but the new zone was not * created yet. */ run_exclusive_enter(inst, &lock_state); - CHECK(ldap_delete_zone2(inst, name, ISC_FALSE)); + CHECK(ldap_delete_zone2(inst, name, false)); CHECK(ldap_parse_master_zoneentry(entry, olddb, inst, task)); cleanup: @@ -2075,14 +2075,14 @@ ldap_parse_master_zoneentry(ldap_entry_t * const entry, dns_db_t * const olddb, dns_zone_t *toview = NULL; isc_result_t result; isc_result_t lock_state = ISC_R_IGNORE; - isc_boolean_t new_zone = ISC_FALSE; - isc_boolean_t want_secure = ISC_FALSE; - isc_boolean_t configured = ISC_FALSE; - isc_boolean_t activity_changed; - isc_boolean_t isactive = ISC_FALSE; + bool new_zone = false; + bool want_secure = false; + bool configured = false; + bool activity_changed; + bool isactive = false; settings_set_t *zone_settings = NULL; - isc_boolean_t ldap_writeback; - isc_boolean_t data_changed = ISC_FALSE; /* GCC */ + bool ldap_writeback; + bool data_changed = false; /* GCC */ isc_uint32_t new_serial; dns_db_t *rbtdb = NULL; @@ -2101,10 +2101,9 @@ ldap_parse_master_zoneentry(ldap_entry_t * const entry, dns_db_t * const olddb, result = ldap_entry_getvalues(entry, "idnsSecInlineSigning", &values); if (result == ISC_R_NOTFOUND || HEAD(values) == NULL) - want_secure = ISC_FALSE; + want_secure = false; else - want_secure = ISC_TF(strcasecmp(HEAD(values)->value, "TRUE") - == 0); + want_secure = (strcasecmp(HEAD(values)->value, "TRUE") == 0); /* Check if we are already serving given zone */ result = zr_get_zone_ptr(inst->zone_register, &entry->fqdn, @@ -2112,13 +2111,13 @@ ldap_parse_master_zoneentry(ldap_entry_t * const entry, dns_db_t * const olddb, if (result == ISC_R_NOTFOUND || result == DNS_R_PARTIALMATCH) { CHECK(create_zone(inst, entry->dn, &entry->fqdn, olddb, want_secure, &raw, &secure)); - new_zone = ISC_TRUE; + new_zone = true; log_debug(2, "created %s: raw %p; secure %p", ldap_entry_logname(entry), raw, secure); } else if (result != ISC_R_SUCCESS) goto cleanup; - else if (want_secure != ISC_TF(secure != NULL)) { - if (want_secure == ISC_TRUE) + else if (want_secure != (secure != NULL)) { + if (want_secure == true) dns_zone_log(raw, ISC_LOG_INFO, "upgrading zone to secure"); else @@ -2150,7 +2149,7 @@ ldap_parse_master_zoneentry(ldap_entry_t * const entry, dns_db_t * const olddb, #else dns_diff_print(&diff, NULL); #endif - if (ldap_writeback == ISC_TRUE) { + if (ldap_writeback == true) { dns_zone_log(raw, ISC_LOG_DEBUG(5), "writing new zone serial " "%u to LDAP", new_serial); result = ldap_replace_serial(inst, &entry->fqdn, new_serial); @@ -2161,30 +2160,30 @@ ldap_parse_master_zoneentry(ldap_entry_t * const entry, dns_db_t * const olddb, } if (!EMPTY(diff.tuples)) { - if (sync_state == sync_finished && new_zone == ISC_FALSE) { + if (sync_state == sync_finished && new_zone == false) { /* write the transaction to journal */ CHECK(zone_journal_adddiff(inst->mctx, raw, &diff)); } /* commit */ CHECK(dns_diff_apply(&diff, rbtdb, version)); - dns_db_closeversion(ldapdb, &version, ISC_TRUE); + dns_db_closeversion(ldapdb, &version, true); dns_zone_markdirty(raw); } else { /* It is necessary to release lock before calling load_zone() * otherwise it will deadlock on newversion() call * in journal roll-forward process! */ - dns_db_closeversion(ldapdb, &version, ISC_FALSE); + dns_db_closeversion(ldapdb, &version, false); } - configured = ISC_TRUE; + configured = true; /* Detect active/inactive zone and activity changes */ result = setting_update_from_ldap_entry("active", zone_settings, "idnsZoneActive", entry); if (result == ISC_R_SUCCESS) { - activity_changed = ISC_TRUE; + activity_changed = true; } else if (result == ISC_R_IGNORE) { - activity_changed = ISC_FALSE; + activity_changed = false; } else goto cleanup; CHECK(setting_get_bool("active", zone_settings, &isactive)); @@ -2193,13 +2192,13 @@ ldap_parse_master_zoneentry(ldap_entry_t * const entry, dns_db_t * const olddb, if (sync_state != sync_finished) goto cleanup; - toview = (want_secure == ISC_TRUE) ? secure : raw; - if (isactive == ISC_TRUE) { - if (new_zone == ISC_TRUE || activity_changed == ISC_TRUE) + toview = (want_secure == true) ? secure : raw; + if (isactive == true) { + if (new_zone == true || activity_changed == true) CHECK(publish_zone(task, inst, toview)); - CHECK(load_zone(toview, ISC_FALSE)); + CHECK(load_zone(toview, false)); CHECK(fwd_configure_zone(zone_settings, inst, &entry->fqdn)); - } else if (activity_changed == ISC_TRUE) { /* Zone was deactivated */ + } else if (activity_changed == true) { /* Zone was deactivated */ CHECK(unpublish_zone(inst, &entry->fqdn, ldap_entry_logname(entry))); /* emulate "no explicit forwarding config" */ @@ -2212,17 +2211,17 @@ ldap_parse_master_zoneentry(ldap_entry_t * const entry, dns_db_t * const olddb, cleanup: dns_diff_clear(&diff); if (rbtdb != NULL && version != NULL) - dns_db_closeversion(ldapdb, &version, ISC_FALSE); /* rollback */ + dns_db_closeversion(ldapdb, &version, false); /* rollback */ if (rbtdb != NULL) dns_db_detach(&rbtdb); if (ldapdb != NULL) dns_db_detach(&ldapdb); - if (new_zone == ISC_TRUE && configured == ISC_FALSE) { + if (new_zone == true && configured == false) { /* Failure in ACL parsing or so. */ log_error_r("%s: publishing failed, rolling back due to", ldap_entry_logname(entry)); /* TODO: verify this */ - result = ldap_delete_zone2(inst, &entry->fqdn, ISC_TRUE); + result = ldap_delete_zone2(inst, &entry->fqdn, true); if (result != ISC_R_SUCCESS) log_error_r("%s: rollback failed: ", ldap_entry_logname(entry)); @@ -2393,8 +2392,8 @@ ldap_substitute_rr_template(isc_mem_t *mctx, const settings_set_t * set, setting_name = tmp + matches[2].rm_so; tmp[matches[2].rm_eo] = '\0'; setting = NULL; - result = setting_find(setting_name, set, isc_boolean_true, - isc_boolean_true, &setting); + result = setting_find(setting_name, set, true, + true, &setting); if (result != ISC_R_SUCCESS) { log_debug(5, "setting '%s' is not defined so it " "cannot be substituted into template '%s'", @@ -2458,7 +2457,7 @@ ldap_parse_rrentry_template(isc_mem_t *mctx, ldap_entry_t *entry, dns_ttl_t ttl; dns_rdatatype_t rdtype; dns_rdatalist_t *rdlist = NULL; - isc_boolean_t did_something = ISC_FALSE; + bool did_something = false; CHECK(str_new(mctx, &orig_val)); rdclass = ldap_entry_getrdclass(entry); @@ -2493,7 +2492,7 @@ ldap_parse_rrentry_template(isc_mem_t *mctx, ldap_entry_t *entry, str_buf(new_val), &rdata)); APPEND(rdlist->rdata, rdata, link); rdata = NULL; - did_something = ISC_TRUE; + did_something = true; } } @@ -2753,7 +2752,7 @@ cleanup: */ static isc_result_t ATTR_NONNULLS ATTR_CHECKRESULT ldap_connect(ldap_instance_t *ldap_inst, ldap_connection_t *ldap_conn, - isc_boolean_t force) + bool force) { LDAP *ld = NULL; int ret; @@ -2817,7 +2816,7 @@ cleanup: static isc_result_t ATTR_NONNULLS ATTR_CHECKRESULT ldap_reconnect(ldap_instance_t *ldap_inst, ldap_connection_t *ldap_conn, - isc_boolean_t force) + bool force) { isc_result_t result; int ret = 0; @@ -2951,7 +2950,7 @@ cleanup: static isc_result_t ATTR_NONNULLS handle_connection_error(ldap_instance_t *ldap_inst, ldap_connection_t *ldap_conn, - isc_boolean_t force) + bool force) { int ret; int err_code; @@ -2989,7 +2988,7 @@ handle_connection_error(ldap_instance_t *ldap_inst, ldap_connection_t *ldap_conn /* Try to reconnect on other errors. */ log_ldap_error(ldap_conn->handle, "connection error"); reconnect: - if (ldap_conn->handle == NULL && force == ISC_FALSE) + if (ldap_conn->handle == NULL && force == false) log_error("connection to the LDAP server was lost"); result = ldap_connect(ldap_inst, ldap_conn, force); if (result == ISC_R_SUCCESS) @@ -3011,12 +3010,12 @@ reconnect: */ isc_result_t ATTR_NONNULLS ATTR_CHECKRESULT ldap_modify_do(ldap_instance_t *ldap_inst, const char *dn, LDAPMod **mods, - isc_boolean_t delete_node) + bool delete_node) { int ret; int err_code; const char *operation_str; - isc_boolean_t once = ISC_FALSE; + bool once = false; isc_result_t result; ldap_connection_t *ldap_conn = NULL; @@ -3045,8 +3044,8 @@ ldap_modify_do(ldap_instance_t *ldap_inst, const char *dn, LDAPMod **mods, * TODO: handle this case inside ldap_pool_getconnection()? */ retry: - once = ISC_TRUE; - CHECK(handle_connection_error(ldap_inst, ldap_conn, ISC_FALSE)); + once = true; + CHECK(handle_connection_error(ldap_inst, ldap_conn, false)); } if (delete_node) { @@ -3109,7 +3108,7 @@ retry: if ((mods[0]->mod_op & ~LDAP_MOD_BVALUES) != LDAP_MOD_DELETE || err_code != LDAP_NO_SUCH_ATTRIBUTE) { result = ISC_R_FAILURE; - if (once == ISC_FALSE) { + if (once == false) { log_error("retrying LDAP operation (%s) on entry '%s'", operation_str, dn); goto retry; @@ -3171,7 +3170,7 @@ cleanup: */ static isc_result_t ATTR_NONNULLS ATTR_CHECKRESULT ldap_rdatalist_to_ldapmod(isc_mem_t *mctx, dns_rdatalist_t *rdlist, - LDAPMod **changep, int mod_op, isc_boolean_t unknown) + LDAPMod **changep, int mod_op, bool unknown) { isc_result_t result; LDAPMod *change = NULL; @@ -3198,12 +3197,12 @@ cleanup: /** * Convert list of DNS Rdata to array of LDAP values. * - * @param[in] unknown ISC_TRUE = use generic (RFC 3597) format, - * ISC_FALSE = use record-specific syntax (if available). + * @param[in] unknown true = use generic (RFC 3597) format, + * false = use record-specific syntax (if available). */ static isc_result_t ATTR_NONNULLS ATTR_CHECKRESULT ldap_rdata_to_char_array(isc_mem_t *mctx, dns_rdata_t *rdata_head, - isc_boolean_t unknown, char ***valsp) + bool unknown, char ***valsp) { isc_result_t result; char **vals; @@ -3231,7 +3230,7 @@ ldap_rdata_to_char_array(isc_mem_t *mctx, dns_rdata_t *rdata_head, /* Convert rdata to text. */ INIT_BUFFER(buffer); - if (unknown == ISC_FALSE) + if (unknown == false) CHECK(dns_rdata_totext(rdata, NULL, &buffer)); else CHECK(rdata_to_generic(rdata, &buffer)); @@ -3346,7 +3345,7 @@ modify_soa_record(ldap_instance_t *ldap_inst, const char *zone_dn, dns_rdata_freestruct((void *)&soa); - result = ldap_modify_do(ldap_inst, zone_dn, changep, ISC_FALSE); + result = ldap_modify_do(ldap_inst, zone_dn, changep, false); cleanup: return result; @@ -3357,19 +3356,19 @@ cleanup: static isc_result_t ATTR_NONNULLS ATTR_CHECKRESULT modify_ldap_common(dns_name_t *owner, dns_name_t *zone, ldap_instance_t *ldap_inst, - dns_rdatalist_t *rdlist, int mod_op, isc_boolean_t delete_node) + dns_rdatalist_t *rdlist, int mod_op, bool delete_node) { isc_result_t result; isc_mem_t *mctx = ldap_inst->mctx; ld_string_t *owner_dn = NULL; LDAPMod *change[3] = { NULL }; - isc_boolean_t zone_sync_ptr; + bool zone_sync_ptr; char **vals = NULL; dns_name_t zone_name; char *zone_dn = NULL; settings_set_t *zone_settings = NULL; int af; /* address family */ - isc_boolean_t unknown_type = ISC_FALSE; + bool unknown_type = false; /* * Find parent zone entry and check if Dynamic Update is allowed. @@ -3388,7 +3387,7 @@ modify_ldap_common(dns_name_t *owner, dns_name_t *zone, ldap_instance_t *ldap_in } CHECK(dn_to_dnsname(mctx, zone_dn, &zone_name, NULL, NULL)); - INSIST(dns_name_equal(zone, &zone_name) == ISC_TRUE); + INSIST(dns_name_equal(zone, &zone_name) == true); result = zr_get_zone_settings(ldap_inst->zone_register, &zone_name, &zone_settings); @@ -3415,7 +3414,7 @@ modify_ldap_common(dns_name_t *owner, dns_name_t *zone, ldap_instance_t *ldap_in /* First, try to store data into named attribute like "URIRecord". * If that fails, try to store the data into "UnknownRecord;TYPE256". */ - unknown_type = ISC_FALSE; + unknown_type = false; do { ldap_mod_free(mctx, &change[0]); CHECK(ldap_rdatalist_to_ldapmod(mctx, rdlist, &change[0], @@ -3423,7 +3422,7 @@ modify_ldap_common(dns_name_t *owner, dns_name_t *zone, ldap_instance_t *ldap_in result = ldap_modify_do(ldap_inst, str_buf(owner_dn), change, delete_node); unknown_type = !unknown_type; /* try again with unknown type */ - } while (result == DNS_R_UNKNOWN && unknown_type == ISC_TRUE); + } while (result == DNS_R_UNKNOWN && unknown_type == true); /* Keep the PTR of corresponding A/AAAA record synchronized. */ if (rdlist->type == dns_rdatatype_a || rdlist->type == dns_rdatatype_aaaa) { @@ -3467,12 +3466,12 @@ cleanup: isc_result_t write_to_ldap(dns_name_t *owner, dns_name_t *zone, ldap_instance_t *ldap_inst, dns_rdatalist_t *rdlist) { - return modify_ldap_common(owner, zone, ldap_inst, rdlist, LDAP_MOD_ADD, ISC_FALSE); + return modify_ldap_common(owner, zone, ldap_inst, rdlist, LDAP_MOD_ADD, false); } isc_result_t remove_values_from_ldap(dns_name_t *owner, dns_name_t *zone, ldap_instance_t *ldap_inst, - dns_rdatalist_t *rdlist, isc_boolean_t delete_node) + dns_rdatalist_t *rdlist, bool delete_node) { return modify_ldap_common(owner, zone, ldap_inst, rdlist, LDAP_MOD_DELETE, delete_node); @@ -3489,7 +3488,7 @@ remove_rdtype_from_ldap(dns_name_t *owner, dns_name_t *zone, LDAPMod *change[2] = { NULL }; ld_string_t *dn = NULL; isc_result_t result; - isc_boolean_t unknown_type = ISC_FALSE; + bool unknown_type = false; CHECK(str_new(ldap_inst->mctx, &dn)); CHECK(dnsname_to_dn(ldap_inst->zone_register, owner, zone, dn)); @@ -3503,10 +3502,10 @@ remove_rdtype_from_ldap(dns_name_t *owner, dns_name_t *zone, unknown_type)); CHECK(isc_string_copy(change[0]->mod_type, LDAP_ATTR_FORMATSIZE, attr)); - CHECK(ldap_modify_do(ldap_inst, str_buf(dn), change, ISC_FALSE)); + CHECK(ldap_modify_do(ldap_inst, str_buf(dn), change, false)); ldap_mod_free(ldap_inst->mctx, &change[0]); unknown_type = !unknown_type; - } while (unknown_type == ISC_TRUE); + } while (unknown_type == true); cleanup: ldap_mod_free(ldap_inst->mctx, &change[0]); @@ -3533,7 +3532,7 @@ remove_entry_from_ldap(dns_name_t *owner, dns_name_t *zone, ldap_instance_t *lda * successful * TODO: handle this case inside ldap_pool_getconnection()? */ - CHECK(ldap_connect(ldap_inst, ldap_conn, ISC_FALSE)); + CHECK(ldap_connect(ldap_inst, ldap_conn, false)); } ret = ldap_delete_ext_s(ldap_conn->handle, str_buf(dn), NULL, NULL); result = (ret == LDAP_SUCCESS) ? ISC_R_SUCCESS : ISC_R_FAILURE; @@ -3669,7 +3668,7 @@ ldap_pool_connect(ldap_pool_t *pool, ldap_instance_t *ldap_inst) for (i = 0; i < pool->connections; i++) { ldap_conn = NULL; CHECK(new_ldap_connection(pool, &ldap_conn)); - result = ldap_connect(ldap_inst, ldap_conn, ISC_FALSE); + result = ldap_connect(ldap_inst, ldap_conn, false); /* Continue even if LDAP server is down */ if (result != ISC_R_NOTCONNECTED && result != ISC_R_TIMEDOUT && result != ISC_R_SUCCESS) { @@ -3726,7 +3725,7 @@ update_zone(isc_task_t *task, isc_event_t *event) INSIST(task == inst->task); /* For task-exclusive mode */ if (SYNCREPL_DEL(pevent->chgtype)) { - CHECK(ldap_delete_zone2(inst, &entry->fqdn, ISC_TRUE)); + CHECK(ldap_delete_zone2(inst, &entry->fqdn, true)); } else { if (entry->class & LDAP_ENTRYCLASS_MASTER) CHECK(ldap_parse_master_zoneentry(entry, NULL, inst, @@ -3836,8 +3835,8 @@ update_record(isc_task_t *task, isc_event_t *event) settings_set_t *zone_settings = NULL; dns_zone_t *raw = NULL; dns_zone_t *secure = NULL; - isc_boolean_t zone_found = ISC_FALSE; - isc_boolean_t zone_reloaded = ISC_FALSE; + bool zone_found = false; + bool zone_reloaded = false; isc_uint32_t serial; ldap_entry_t *entry = pevent->entry; @@ -3870,7 +3869,7 @@ update_record(isc_task_t *task, isc_event_t *event) REQUIRE(inst != NULL); CHECK(zr_get_zone_ptr(inst->zone_register, &entry->zone_name, &raw, &secure)); - zone_found = ISC_TRUE; + zone_found = true; update_restart: rbtdb = NULL; @@ -3880,7 +3879,7 @@ update_restart: CHECK(zr_get_zone_dbs(inst->zone_register, &entry->zone_name, &ldapdb, &rbtdb)); CHECK(dns_db_newversion(ldapdb, &version)); - CHECK(dns_db_findnode(rbtdb, &entry->fqdn, ISC_TRUE, &node)); + CHECK(dns_db_findnode(rbtdb, &entry->fqdn, true, &node)); result = dns_db_allrdatasets(rbtdb, node, version, 0, &rbt_rds_iterator); if (result != ISC_R_SUCCESS && result != ISC_R_NOTFOUND) goto cleanup; @@ -3967,7 +3966,7 @@ update_restart: } /* commit */ CHECK(dns_diff_apply(&diff, rbtdb, version)); - dns_db_closeversion(ldapdb, &version, ISC_TRUE); + dns_db_closeversion(ldapdb, &version, true); dns_zone_markdirty(raw); } @@ -3989,7 +3988,7 @@ cleanup: dns_db_detachnode(rbtdb, &node); /* rollback */ if (rbtdb != NULL && version != NULL) - dns_db_closeversion(ldapdb, &version, ISC_FALSE); + dns_db_closeversion(ldapdb, &version, false); if (rbtdb != NULL) dns_db_detach(&rbtdb); if (ldapdb != NULL) @@ -4001,16 +4000,16 @@ cleanup: "reload triggered by change in %s", ldap_entry_logname(entry)); if (secure != NULL) - result = load_zone(secure, ISC_TRUE); + result = load_zone(secure, true); else if (raw != NULL) - result = load_zone(raw, ISC_TRUE); + result = load_zone(raw, true); if (result == ISC_R_SUCCESS || result == DNS_R_UPTODATE || result == DNS_R_DYNAMIC || result == DNS_R_CONTINUE) { /* zone reload succeeded, fire current event again */ log_debug(1, "restarting update_record after zone reload " "caused by change in %s", ldap_entry_logname(entry)); - zone_reloaded = ISC_TRUE; + zone_reloaded = true; result = dns_zone_getserial2(raw, &serial); if (result == ISC_R_SUCCESS) goto update_restart; @@ -4050,7 +4049,7 @@ cleanup: isc_result_t ldap_dn_compare(const char *dn1_instr, const char *dn2_instr, - isc_boolean_t *isequal) { + bool *isequal) { int ret; isc_result_t result; LDAPDN dn1_ldap = NULL; @@ -4074,7 +4073,7 @@ ldap_dn_compare(const char *dn1_instr, const char *dn2_instr, if (ret != LDAP_SUCCESS) CLEANUP_WITH(ISC_R_FAILURE); - *isequal = ISC_TF(strcasecmp(dn1_outstr, dn2_outstr) == 0); + *isequal = (strcasecmp(dn1_outstr, dn2_outstr) == 0); result = ISC_R_SUCCESS; cleanup: @@ -4111,7 +4110,7 @@ syncrepl_update(ldap_instance_t *inst, ldap_entry_t **entryp, int chgtype) dns_zone_t *zone_ptr = NULL; isc_taskaction_t action = NULL; isc_task_t *task = NULL; - isc_boolean_t synchronous; + bool synchronous; REQUIRE(inst != NULL); REQUIRE(entryp != NULL); @@ -4135,12 +4134,12 @@ syncrepl_update(ldap_instance_t *inst, ldap_entry_t **entryp, int chgtype) CHECK(zr_get_zone_ptr(inst->zone_register, zone_name, &zone_ptr, NULL)); dns_zone_gettask(zone_ptr, &task); - synchronous = ISC_FALSE; + synchronous = false; } else { /* For configuration object and zone object use single task * to make sure that the exclusive mode actually works. */ isc_task_attach(inst->task, &task); - synchronous = ISC_TRUE; + synchronous = true; } REQUIRE(task != NULL); @@ -4216,9 +4215,9 @@ cleanup: /* * This "sane" sleep allows us to end if signal set the "exiting" variable. * - * Returns ISC_FALSE if we should terminate, ISC_TRUE otherwise. + * Returns false if we should terminate, true otherwise. */ -static inline isc_boolean_t ATTR_NONNULLS +static inline bool ATTR_NONNULLS sane_sleep(const ldap_instance_t *inst, unsigned int timeout) { unsigned int remains = timeout; @@ -4229,7 +4228,7 @@ sane_sleep(const ldap_instance_t *inst, unsigned int timeout) if (remains) log_debug(99, "sane_sleep: interrupted"); - return inst->exiting ? ISC_FALSE : ISC_TRUE; + return inst->exiting ? false : true; } /* No-op signal handler for SIGUSR1 */ @@ -4245,7 +4244,7 @@ install_usr1handler(void) struct sigaction sa; struct sigaction oldsa; int ret; - static isc_boolean_t once = ISC_FALSE; + static bool once = false; if (once) return; @@ -4259,7 +4258,7 @@ install_usr1handler(void) /* Don't attempt to replace already existing handler */ RUNTIME_CHECK(oldsa.sa_handler == NULL); - once = ISC_TRUE; + once = true; } /* @@ -4296,8 +4295,8 @@ int ldap_sync_search_entry ( ldap_entry_t *new_entry = NULL; isc_result_t result; metadb_node_t *node = NULL; - isc_boolean_t mldap_open = ISC_FALSE; - isc_boolean_t modrdn = ISC_FALSE; + bool mldap_open = false; + bool modrdn = false; #ifdef RBTDB_DEBUG static unsigned int count = 0; @@ -4307,7 +4306,7 @@ int ldap_sync_search_entry ( return LDAP_SUCCESS; CHECK(mldap_newversion(inst->mldapdb)); - mldap_open = ISC_TRUE; + mldap_open = true; CHECK(sync_concurr_limit_wait(inst->sctx)); log_debug(20, "ldap_sync_search_entry phase: %x", phase); @@ -4335,7 +4334,7 @@ int ldap_sync_search_entry ( &new_entry->zone_name) && dns_name_equal(&old_entry->fqdn, &new_entry->fqdn)); - if (modrdn == ISC_TRUE) { + if (modrdn == true) { log_debug(1, "detected entry rename: %s -> %s", ldap_entry_logname(old_entry), ldap_entry_logname(new_entry)); @@ -4346,7 +4345,7 @@ int ldap_sync_search_entry ( ldap_entry_logname(new_entry)); } } - if (phase == LDAP_SYNC_CAPI_DELETE || modrdn == ISC_TRUE) { + if (phase == LDAP_SYNC_CAPI_DELETE || modrdn == true) { /* delete old entry from zone and metaDB */ CHECK(syncrepl_update(inst, &old_entry, LDAP_SYNC_CAPI_DELETE)); CHECK(mldap_entry_delete(inst->mldapdb, entryUUID)); @@ -4361,11 +4360,11 @@ int ldap_sync_search_entry ( &new_entry->zone_name, node)); /* commit new entry into metaLDAP DB before something breaks */ metadb_node_close(&node); - mldap_closeversion(inst->mldapdb, ISC_TRUE); - mldap_open = ISC_FALSE; + mldap_closeversion(inst->mldapdb, true); + mldap_open = false; /* re-add entry under new DN, if necessary */ CHECK(syncrepl_update(inst, &new_entry, - (modrdn == ISC_TRUE) + (modrdn == true) ? LDAP_SYNC_CAPI_ADD : phase)); } if (phase != LDAP_SYNC_CAPI_ADD && phase != LDAP_SYNC_CAPI_MODIFY && @@ -4382,9 +4381,9 @@ int ldap_sync_search_entry ( cleanup: metadb_node_close(&node); - if (mldap_open == ISC_TRUE) + if (mldap_open == true) /* commit metaDB changes if the syncrepl event was sent */ - mldap_closeversion(inst->mldapdb, ISC_TF(result == ISC_R_SUCCESS)); + mldap_closeversion(inst->mldapdb, (result == ISC_R_SUCCESS)); if (result != ISC_R_SUCCESS) { log_error_r("ldap_sync_search_entry failed"); sync_concurr_limit_signal(inst->sctx); @@ -4717,7 +4716,7 @@ ldap_syncrepl_watcher(isc_threadarg_t arg) goto retry; } - result = ldap_connect(inst, conn, ISC_TRUE); + result = ldap_connect(inst, conn, true); if (result != ISC_R_SUCCESS) { log_error_r("reconnection to LDAP failed"); goto retry; @@ -4756,7 +4755,7 @@ retry: reconnect_interval == 1 ? "": "s"); if (!sane_sleep(inst, reconnect_interval)) CLEANUP_WITH(ISC_R_SHUTTINGDOWN); - handle_connection_error(inst, conn, ISC_TRUE); + handle_connection_error(inst, conn, true); } } @@ -4810,7 +4809,7 @@ ldap_instance_attachmem(ldap_instance_t *ldap_inst, isc_mem_t **mctx) isc_mem_attach(ldap_inst->mctx, mctx); } -isc_boolean_t +bool ldap_instance_isexiting(ldap_instance_t *ldap_inst) { return ldap_inst->exiting; @@ -4825,9 +4824,9 @@ ldap_instance_taint(ldap_instance_t *ldap_inst) { isc_refcount_increment0(&ldap_inst->errors, NULL); } -isc_boolean_t +bool ldap_instance_istained(ldap_instance_t *ldap_inst) { - return ISC_TF(isc_refcount_current(&ldap_inst->errors) != 0); + return (isc_refcount_current(&ldap_inst->errors) != 0); } /** diff --git a/src/ldap_helper.h b/src/ldap_helper.h index fc21bb3..6ac6282 100644 --- a/src/ldap_helper.h +++ b/src/ldap_helper.h @@ -7,7 +7,6 @@ #include "types.h" -#include #include #include #include @@ -48,7 +47,7 @@ new_ldap_instance(isc_mem_t *mctx, const char *db_name, const char *parameters, void destroy_ldap_instance(ldap_instance_t **ldap_inst) ATTR_NONNULLS; isc_result_t -ldap_delete_zone2(ldap_instance_t *inst, dns_name_t *name, isc_boolean_t lock) +ldap_delete_zone2(ldap_instance_t *inst, dns_name_t *name, bool lock) ATTR_NONNULLS; /* Functions for writing to LDAP. */ @@ -57,7 +56,7 @@ isc_result_t write_to_ldap(dns_name_t *owner, dns_name_t *zone, ldap_instance_t isc_result_t remove_values_from_ldap(dns_name_t *owner, dns_name_t *zone, ldap_instance_t *ldap_inst, - dns_rdatalist_t *rdlist, isc_boolean_t delete_node) ATTR_NONNULLS; + dns_rdatalist_t *rdlist, bool delete_node) ATTR_NONNULLS; isc_result_t remove_rdtype_from_ldap(dns_name_t *owner, dns_name_t *zone, @@ -72,7 +71,7 @@ ldap_mod_create(isc_mem_t *mctx, LDAPMod **changep); isc_result_t ATTR_NONNULLS ATTR_CHECKRESULT ldap_modify_do(ldap_instance_t *ldap_inst, const char *dn, LDAPMod **mods, - isc_boolean_t delete_node); + bool delete_node); void ATTR_NONNULLS ldap_mod_free(isc_mem_t *mctx, LDAPMod **changep); @@ -89,7 +88,7 @@ isc_result_t activate_zones(isc_task_t *task, ldap_instance_t *inst) ATTR_NONNUL isc_task_t * ldap_instance_gettask(ldap_instance_t *ldap_inst); -isc_boolean_t ldap_instance_isexiting(ldap_instance_t *ldap_inst) ATTR_NONNULLS ATTR_CHECKRESULT; +bool ldap_instance_isexiting(ldap_instance_t *ldap_inst) ATTR_NONNULLS ATTR_CHECKRESULT; void ldap_instance_taint(ldap_instance_t *ldap_inst) ATTR_NONNULLS; diff --git a/src/metadb.c b/src/metadb.c index 797fcc9..2a996e1 100644 --- a/src/metadb.c +++ b/src/metadb.c @@ -36,7 +36,7 @@ isc_result_t metadb_new(isc_mem_t *mctx, metadb_t **mdbp) { isc_result_t result; metadb_t *mdb = NULL; - isc_boolean_t lock_ready = ISC_FALSE; + bool lock_ready = false; REQUIRE(mdbp != NULL && *mdbp == NULL); @@ -46,7 +46,7 @@ metadb_new(isc_mem_t *mctx, metadb_t **mdbp) { isc_mem_attach(mctx, &mdb->mctx); CHECK(isc_mutex_init(&mdb->newversion_lock)); - lock_ready = ISC_TRUE; + lock_ready = true; CHECK(dns_db_create(mctx, "rbt", dns_rootname, dns_dbtype_zone, dns_rdataclass_in, 0, NULL, &mdb->rbtdb)); @@ -55,7 +55,7 @@ metadb_new(isc_mem_t *mctx, metadb_t **mdbp) { cleanup: if (mdb != NULL) { - if (lock_ready == ISC_TRUE) + if (lock_ready == true) RUNTIME_CHECK(isc_mutex_destroy(&mdb->newversion_lock) == ISC_R_SUCCESS); MEM_PUT_AND_DETACH(mdb); @@ -114,10 +114,10 @@ cleanup: * Close writeable metaDB version and commit/discard all changes. * * @pre All metaDB nodes have to be closed before calling - * closeversion(commit = ISC_TRUE). + * closeversion(commit = true). */ void -metadb_closeversion(metadb_t *mdb, isc_boolean_t commit) { +metadb_closeversion(metadb_t *mdb, bool commit) { UNLOCK(&mdb->newversion_lock); dns_db_closeversion(mdb->rbtdb, &mdb->newversion, commit); } @@ -141,7 +141,7 @@ metadb_iterator_destroy(metadb_iter_t **miterp) { if (miter->version != NULL) dns_db_closeversion(miter->rbtdb, &miter->version, - ISC_FALSE); + false); dns_db_detach(&miter->rbtdb); } @@ -195,7 +195,7 @@ metadb_node_close(metadb_node_t **nodep) { dns_db_detachnode(node->rbtdb, &node->dbnode); if (node->version != NULL) dns_db_closeversion(node->rbtdb, &node->version, - ISC_FALSE); + false); dns_db_detach(&node->rbtdb); } MEM_PUT_AND_DETACH(node); @@ -252,7 +252,7 @@ cleanup: */ static isc_result_t metadb_node_init(metadb_t *mdb, dns_dbversion_t *ver, dns_name_t *mname, - isc_boolean_t create, metadb_node_t **nodep) { + bool create, metadb_node_t **nodep) { isc_result_t result; metadb_node_t *node = NULL; @@ -288,10 +288,10 @@ metadb_readnode_open(metadb_t *mdb, dns_name_t *mname, metadb_node_t **nodep) { dns_dbversion_t *ver = NULL; dns_db_currentversion(mdb->rbtdb, &ver); - CHECK(metadb_node_init(mdb, ver, mname, ISC_FALSE, nodep)); + CHECK(metadb_node_init(mdb, ver, mname, false, nodep)); cleanup: - dns_db_closeversion(mdb->rbtdb, &ver, ISC_FALSE); + dns_db_closeversion(mdb->rbtdb, &ver, false); return result; } @@ -311,10 +311,10 @@ metadb_writenode_create(metadb_t *mdb, dns_name_t *mname, metadb_node_t **nodep) INSIST(mdb->newversion != NULL); dns_db_attachversion(mdb->rbtdb, mdb->newversion, &ver); - CHECK(metadb_node_init(mdb, ver, mname, ISC_TRUE, nodep)); + CHECK(metadb_node_init(mdb, ver, mname, true, nodep)); cleanup: - dns_db_closeversion(mdb->rbtdb, &ver, ISC_FALSE); + dns_db_closeversion(mdb->rbtdb, &ver, false); return result; } @@ -334,10 +334,10 @@ metadb_writenode_open(metadb_t *mdb, dns_name_t *mname, metadb_node_t **nodep) { INSIST(mdb->newversion != NULL); dns_db_attachversion(mdb->rbtdb, mdb->newversion, &ver); - CHECK(metadb_node_init(mdb, ver, mname, ISC_FALSE, nodep)); + CHECK(metadb_node_init(mdb, ver, mname, false, nodep)); cleanup: - dns_db_closeversion(mdb->rbtdb, &ver, ISC_FALSE); + dns_db_closeversion(mdb->rbtdb, &ver, false); return result; } @@ -392,7 +392,7 @@ metadb_rdataset_get(metadb_node_t *node, dns_rdatatype_t rrtype, dns_rdataset_t *rdataset) { isc_result_t result; - REQUIRE(dns_rdataset_isassociated(rdataset) == ISC_FALSE); + REQUIRE(dns_rdataset_isassociated(rdataset) == false); CHECK(dns_db_findrdataset(node->rbtdb, node->dbnode, node->version, rrtype, 0, 0, rdataset, NULL)); diff --git a/src/metadb.h b/src/metadb.h index a1cd136..44bb0e5 100644 --- a/src/metadb.h +++ b/src/metadb.h @@ -49,7 +49,7 @@ isc_result_t ATTR_CHECKRESULT ATTR_NONNULLS metadb_newversion(metadb_t *mdb); void ATTR_NONNULLS -metadb_closeversion(metadb_t *mdb, isc_boolean_t commit); +metadb_closeversion(metadb_t *mdb, bool commit); isc_result_t ATTR_CHECKRESULT ATTR_NONNULLS metadb_iterator_create(metadb_t *mdb, metadb_iter_t **miterp); diff --git a/src/mldap.c b/src/mldap.c index 8b90921..a6e5971 100644 --- a/src/mldap.c +++ b/src/mldap.c @@ -9,7 +9,6 @@ #include #include -#include #include #include #include @@ -98,7 +97,7 @@ mldap_newversion(mldapdb_t *mldap) { } void -mldap_closeversion(mldapdb_t *mldap, isc_boolean_t commit) { +mldap_closeversion(mldapdb_t *mldap, bool commit) { return metadb_closeversion(mldap->mdb, commit); } @@ -497,14 +496,14 @@ mldap_iter_deadnodes_next(mldapdb_t *mldap, metadb_iter_t **iterp, metadb_node.rbtdb = iter->rbtdb; /* skip nodes which do not belong to UUID sub-tree or are 'fresh' */ - while (ISC_TRUE) { + while (true) { if (rbt_node != NULL) dns_db_detachnode(iter->rbtdb, &rbt_node); dns_name_reset(&name); CHECK(dns_dbiterator_next(iter->iter)); CHECK(dns_dbiterator_current(iter->iter, &rbt_node, &name)); - if (dns_name_issubdomain(&name, &uuid_rootname) == ISC_FALSE) + if (dns_name_issubdomain(&name, &uuid_rootname) == false) continue; metadb_node.dbnode = rbt_node; diff --git a/src/mldap.h b/src/mldap.h index c682d48..ee04403 100644 --- a/src/mldap.h +++ b/src/mldap.h @@ -22,7 +22,7 @@ isc_result_t ATTR_CHECKRESULT ATTR_NONNULLS mldap_newversion(mldapdb_t *mldap); void ATTR_NONNULLS -mldap_closeversion(mldapdb_t *mldap, isc_boolean_t commit); +mldap_closeversion(mldapdb_t *mldap, bool commit); isc_result_t ATTR_CHECKRESULT ATTR_NONNULLS mldap_entry_read(mldapdb_t *mldap, struct berval *uuid, metadb_node_t **nodep); diff --git a/src/settings.c b/src/settings.c index 180f027..451f63e 100644 --- a/src/settings.c +++ b/src/settings.c @@ -25,7 +25,7 @@ #include "ldap_helper.h" #include "zone_register.h" -isc_boolean_t verbose_checks = ISC_FALSE; /* log each failure in CHECK() macro */ +bool verbose_checks = false; /* log each failure in CHECK() macro */ /** Built-in defaults. */ static const setting_t settings_default[] = { @@ -48,8 +48,8 @@ static const setting_t settings_default[] = { { "krb5_keytab", default_string("") }, { "fake_mname", default_string("") }, { "ldap_hostname", default_string("") }, - { "sync_ptr", default_boolean(ISC_FALSE) }, - { "dyn_update", default_boolean(ISC_FALSE) }, + { "sync_ptr", default_boolean(false) }, + { "dyn_update", default_boolean(false) }, /* Empty string as default update_policy declares zone as 'dynamic' * for dns_zone_isdynamic() to prevent unwanted * zone_postload() calls and warnings about serial and so on. @@ -57,7 +57,7 @@ static const setting_t settings_default[] = { * SSU table defined by empty string contains no rules => * dns_ssutable_checkrules() will return deny. */ { "update_policy", default_string("") }, - { "verbose_checks", default_boolean(ISC_FALSE) }, + { "verbose_checks", default_boolean(false) }, { "directory", default_string("") }, { "server_id", default_string("") }, end_of_settings @@ -87,7 +87,7 @@ const settings_set_t settings_default_set = { */ isc_result_t setting_find(const char *name, const settings_set_t *set, - isc_boolean_t recursive, isc_boolean_t filled_only, + bool recursive, bool filled_only, setting_t **found) { REQUIRE(name != NULL); @@ -150,7 +150,7 @@ setting_get(const char *const name, const setting_type_t type, REQUIRE(name != NULL); REQUIRE(target != NULL); - CHECK(setting_find(name, set, isc_boolean_true, isc_boolean_true, &setting)); + CHECK(setting_find(name, set, true, true, &setting)); if (setting->type != type) { log_bug("incompatible setting data type requested " @@ -166,7 +166,7 @@ setting_get(const char *const name, const setting_type_t type, *(char **)target = setting->value.value_char; break; case ST_BOOLEAN: - *(isc_boolean_t *)target = setting->value.value_boolean; + *(bool *)target = setting->value.value_boolean; break; default: UNEXPECTED_ERROR(__FILE__, __LINE__, @@ -197,7 +197,7 @@ setting_get_str(const char *const name, const settings_set_t *const set, isc_result_t setting_get_bool(const char *const name, const settings_set_t *const set, - isc_boolean_t *target) + bool *target) { return setting_get(name, ST_BOOLEAN, set, target); } @@ -265,7 +265,7 @@ set_value(isc_mem_t *mctx, const settings_set_t *set, setting_t *setting, CLEANUP_WITH(ISC_R_UNEXPECTEDTOKEN); } if (setting->filled && - setting->value.value_boolean == ISC_TF(numeric_value)) + setting->value.value_boolean == numeric_value) CLEANUP_WITH(ISC_R_IGNORE); break; default: @@ -280,7 +280,7 @@ set_value(isc_mem_t *mctx, const settings_set_t *set, setting_t *setting, if (setting->is_dynamic) isc_mem_free(mctx, setting->value.value_char); CHECKED_MEM_ALLOCATE(mctx, setting->value.value_char, len); - setting->is_dynamic = ISC_TRUE; + setting->is_dynamic = true; CHECK(isc_string_copy(setting->value.value_char, len, value)); break; @@ -289,7 +289,7 @@ set_value(isc_mem_t *mctx, const settings_set_t *set, setting_t *setting, break; case ST_BOOLEAN: - setting->value.value_boolean = ISC_TF(numeric_value); + setting->value.value_boolean = numeric_value; break; default: UNEXPECTED_ERROR(__FILE__, __LINE__, @@ -328,7 +328,7 @@ setting_set(const char *const name, const settings_set_t *set, isc_result_t result; setting_t *setting = NULL; - CHECK(setting_find(name, set, ISC_FALSE, ISC_FALSE, &setting)); + CHECK(setting_find(name, set, false, false, &setting)); return set_value(set->mctx, set, setting, value); @@ -359,7 +359,7 @@ setting_unset(const char *const name, const settings_set_t *set) isc_result_t result; setting_t *setting = NULL; - CHECK(setting_find(name, set, ISC_FALSE, ISC_FALSE, &setting)); + CHECK(setting_find(name, set, false, false, &setting)); if (!setting->filled) return ISC_R_IGNORE; @@ -370,7 +370,7 @@ setting_unset(const char *const name, const settings_set_t *set) case ST_STRING: if (setting->is_dynamic) isc_mem_free(set->mctx, setting->value.value_char); - setting->is_dynamic = ISC_FALSE; + setting->is_dynamic = false; break; case ST_UNSIGNED_INTEGER: @@ -411,7 +411,7 @@ setting_update_from_ldap_entry(const char *name, settings_set_t *set, setting_t *setting = NULL; ldap_valuelist_t values; - CHECK(setting_find(name, set, ISC_FALSE, ISC_FALSE, &setting)); + CHECK(setting_find(name, set, false, false, &setting)); result = ldap_entry_getvalues(entry, attr_name, &values); if (result == ISC_R_NOTFOUND || HEAD(values) == NULL) { CHECK(setting_unset(name, set)); @@ -559,7 +559,7 @@ cfg_printer(void *closure, const char *text, int textlen) { isc_buffer_t *logbuffer = closure; REQUIRE(logbuffer != NULL); - REQUIRE(logbuffer->autore == ISC_TRUE); + REQUIRE(logbuffer->autore == true); isc_buffer_putmem(logbuffer, (const unsigned char *)text, textlen); } @@ -583,10 +583,10 @@ settings_set_fill(const cfg_obj_t *config, settings_set_t *set) const cfg_obj_t *cfg_value; const char *str_value; - REQUIRE(cfg_obj_ismap(config) == ISC_TRUE); + REQUIRE(cfg_obj_ismap(config) == true); CHECK(isc_buffer_allocate(set->mctx, &buf_value, ISC_BUFFER_INCR)); - isc_buffer_setautorealloc(buf_value, ISC_TRUE); + isc_buffer_setautorealloc(buf_value, true); for (setting = set->first_setting; setting->name != NULL; @@ -628,23 +628,23 @@ cleanup: * * Error message is logged for each setting without defined value. * - * @retval ISC_TRUE All settings have value defined. - * @retval ISC_FALSE At least one setting do not have defined value. + * @retval true All settings have value defined. + * @retval false At least one setting do not have defined value. */ -isc_boolean_t +bool settings_set_isfilled(settings_set_t *set) { isc_result_t result; - isc_boolean_t isfiled = ISC_TRUE; + bool isfiled = true; REQUIRE(set != NULL); for (int i = 0; set->first_setting[i].name != NULL; i++) { const char *name = set->first_setting[i].name; - result = setting_find(name, set, ISC_TRUE, ISC_TRUE, NULL); + result = setting_find(name, set, true, true, NULL); if (result != ISC_R_SUCCESS) { log_error_r("argument '%s' must be set " "in set of settings '%s'", name, set->name); - isfiled = ISC_FALSE; + isfiled = false; } } return isfiled; @@ -679,7 +679,7 @@ setting_set_parse_conf(isc_mem_t *mctx, const char *name, REQUIRE(parameters != NULL); CHECK(isc_buffer_allocate(mctx, &log_buf, ISC_BUFFER_INCR)); - isc_buffer_setautorealloc(log_buf, ISC_TRUE); + isc_buffer_setautorealloc(log_buf, true); len = strlen(parameters); isc_buffer_constinit(&in_buf, parameters, len); diff --git a/src/settings.h b/src/settings.h index 6585d8b..724deb0 100644 --- a/src/settings.h +++ b/src/settings.h @@ -6,7 +6,6 @@ #define _LD_SETTINGS_H_ #include -#include #include #include @@ -35,10 +34,10 @@ struct setting { union { char *value_char; isc_uint32_t value_uint; - isc_boolean_t value_boolean; + bool value_boolean; } value; - isc_boolean_t filled; - isc_boolean_t is_dynamic; + bool filled; + bool is_dynamic; }; struct settings_set { @@ -61,13 +60,13 @@ struct settings_set { * "name", no_default_string, &target_variable * } */ -#define default_string(val) ST_STRING, { .value_char = (val) }, ISC_TRUE, ISC_FALSE -#define default_uint(val) ST_UNSIGNED_INTEGER, { .value_uint = (val) }, ISC_TRUE, ISC_FALSE -#define default_boolean(val) ST_BOOLEAN, { .value_boolean = (val) }, ISC_TRUE, ISC_FALSE +#define default_string(val) ST_STRING, { .value_char = (val) }, true, false +#define default_uint(val) ST_UNSIGNED_INTEGER, { .value_uint = (val) }, true, false +#define default_boolean(val) ST_BOOLEAN, { .value_boolean = (val) }, true, false /* No defaults. */ -#define no_default_string ST_STRING, { .value_char = NULL }, ISC_FALSE, ISC_FALSE -#define no_default_uint ST_UNSIGNED_INTEGER, { .value_uint = 0 }, ISC_FALSE, ISC_FALSE -#define no_default_boolean ST_BOOLEAN, { .value_boolean = ISC_FALSE }, ISC_FALSE, ISC_FALSE +#define no_default_string ST_STRING, { .value_char = NULL }, false, false +#define no_default_uint ST_UNSIGNED_INTEGER, { .value_uint = 0 }, false, false +#define no_default_boolean ST_BOOLEAN, { .value_boolean = false }, false, false /* This is used in the end of setting_t arrays. */ #define end_of_settings { NULL, default_uint(0) } @@ -90,12 +89,12 @@ setting_set_parse_conf(isc_mem_t *mctx, const char *name, const char *file, unsigned long line, settings_set_t *settings) ATTR_NONNULLS ATTR_CHECKRESULT; -isc_boolean_t +bool settings_set_isfilled(settings_set_t *set) ATTR_NONNULLS ATTR_CHECKRESULT; isc_result_t setting_find(const char *name, const settings_set_t *set, - isc_boolean_t recursive, isc_boolean_t filled_only, + bool recursive, bool filled_only, setting_t **found) ATTR_CHECKRESULT; isc_result_t @@ -108,7 +107,7 @@ setting_get_str(const char * const name, const settings_set_t * const set, isc_result_t setting_get_bool(const char * const name, const settings_set_t * const set, - isc_boolean_t * target) ATTR_NONNULLS ATTR_CHECKRESULT; + bool * target) ATTR_NONNULLS ATTR_CHECKRESULT; isc_result_t setting_set(const char *const name, const settings_set_t *set, diff --git a/src/syncptr.c b/src/syncptr.c index 7c3d800..0c3743d 100644 --- a/src/syncptr.c +++ b/src/syncptr.c @@ -177,7 +177,7 @@ cleanup: * or LDAP_MOD_ADD if A/AAAA record is being added. * @param[out] rdataset Will be set to the existing PTR RR set in the database. * RR set exists only if dns_rdataset_isassociated() - * returns ISC_TRUE. + * returns true. * * @retval ISC_R_IGNORE A and PTR records match, no change is required. * @retval ISC_R_SUCCESS Prerequisites fulfilled, update is allowed. @@ -216,10 +216,10 @@ sync_ptr_validate(dns_name_t *a_name, const char *a_name_str, const char *ip_str isc_result_t result; char ptr_name_str[DNS_NAME_FORMATSIZE + 1]; - isc_boolean_t ptr_found; + bool ptr_found; dns_rdata_ptr_t ptr_rdata; char ptr_rdata_str[DNS_NAME_FORMATSIZE + 1]; - isc_boolean_t ptr_a_equal = ISC_FALSE; /* GCC requires initialization */ + bool ptr_a_equal = false; /* GCC requires initialization */ dns_dbnode_t *ptr_node = NULL; dns_fixedname_t found_name; @@ -238,14 +238,14 @@ sync_ptr_validate(dns_name_t *a_name, const char *a_name_str, const char *ip_str switch (result) { case ISC_R_SUCCESS: INSIST(dns_name_equal(dns_fixedname_name(&found_name), - ptr_name) == ISC_TRUE); - ptr_found = ISC_TRUE; + ptr_name) == true); + ptr_found = true; break; case DNS_R_NXDOMAIN: case DNS_R_NXRRSET: case DNS_R_EMPTYNAME: - ptr_found = ISC_FALSE; + ptr_found = false; /* PTR RR does not exist */ break; @@ -258,7 +258,7 @@ sync_ptr_validate(dns_name_t *a_name, const char *a_name_str, const char *ip_str } /* Find the value of PTR entry. */ - if (ptr_found == ISC_TRUE) { + if (ptr_found == true) { INSIST(dns_rdataset_count(rdataset) > 0); if (dns_rdataset_count(rdataset) != 1) { dns_name_format(ptr_name, ptr_name_str, @@ -278,9 +278,9 @@ sync_ptr_validate(dns_name_t *a_name, const char *a_name_str, const char *ip_str if (dns_name_isabsolute(a_name) && dns_name_isabsolute(&ptr_rdata.ptr) && dns_name_equal(&ptr_rdata.ptr, a_name)) { - ptr_a_equal = ISC_TRUE; + ptr_a_equal = true; } else { - ptr_a_equal = ISC_FALSE; + ptr_a_equal = false; dns_name_format(ptr_name, ptr_name_str, DNS_NAME_FORMATSIZE); append_trailing_dot(ptr_name_str, @@ -293,13 +293,13 @@ sync_ptr_validate(dns_name_t *a_name, const char *a_name_str, const char *ip_str } if (mod_op == LDAP_MOD_DELETE) { - if (ptr_found == ISC_FALSE) { + if (ptr_found == false) { dns_zone_log(zone, ISC_LOG_DEBUG(3), SYNCPTR_FMTPRE "skipped: no PTR records found", SYNCPTR_FMTPOST); CLEANUP_WITH(ISC_R_IGNORE); - } else if (ptr_a_equal == ISC_FALSE) { + } else if (ptr_a_equal == false) { dns_zone_log(zone, ISC_LOG_ERROR, SYNCPTR_FMTPRE "failed: " "existing PTR record '%s' contains unexpected " "value '%s' (value '%s' expected)", @@ -308,8 +308,8 @@ sync_ptr_validate(dns_name_t *a_name, const char *a_name_str, const char *ip_str CLEANUP_WITH(ISC_R_UNEXPECTEDTOKEN); } - } else if (mod_op == LDAP_MOD_ADD && ptr_found == ISC_TRUE) { - if (ptr_a_equal == ISC_TRUE) { + } else if (mod_op == LDAP_MOD_ADD && ptr_found == true) { + if (ptr_a_equal == true) { dns_zone_log(zone, ISC_LOG_DEBUG(3), SYNCPTR_FMTPRE "skipped: PTR record with " "desired value is already present", @@ -380,7 +380,7 @@ sync_ptr_init(isc_mem_t *mctx, dns_zt_t * zonetable, isc_result_t result; settings_set_t *zone_settings = NULL; - isc_boolean_t zone_dyn_update; + bool zone_dyn_update; char *a_name_str = NULL; sync_ptrev_t *ev = NULL; @@ -508,7 +508,7 @@ sync_ptr_handler(isc_task_t *task, isc_event_t *event) { } CHECK(dns_diff_apply(&diff, ldapdb, version)); - dns_db_closeversion(ldapdb, &version, ISC_TRUE); + dns_db_closeversion(ldapdb, &version, true); cleanup: if (dns_rdataset_isassociated(&old_rdataset)) @@ -519,7 +519,7 @@ cleanup: if (ldapdb != NULL) { /* rollback if something bad happened */ if (version != NULL) - dns_db_closeversion(ldapdb, &version, ISC_FALSE); + dns_db_closeversion(ldapdb, &version, false); dns_db_detach(&ldapdb); } sync_ptr_destroyev(&ev); diff --git a/src/syncrepl.c b/src/syncrepl.c index 6ed8051..8bb340a 100644 --- a/src/syncrepl.c +++ b/src/syncrepl.c @@ -145,7 +145,7 @@ finish(isc_task_t *task, isc_event_t *event) { "sync_barrier_wait(): invalid state " "%u", bev->sctx->state); } - sync_state_change(bev->sctx, new_state, ISC_FALSE); + sync_state_change(bev->sctx, new_state, false); BROADCAST(&bev->sctx->cond); UNLOCK(&bev->sctx->mutex); if (new_state == sync_finished) @@ -203,7 +203,7 @@ barrier_decrement(isc_task_t *task, isc_event_t *event) { sync_barrierev_t *fev = NULL; isc_event_t *ev = NULL; isc_uint32_t cnt; - isc_boolean_t locked = ISC_FALSE; + bool locked = false; REQUIRE(ISCAPI_TASK_VALID(task)); REQUIRE(event != NULL); @@ -213,7 +213,7 @@ barrier_decrement(isc_task_t *task, isc_event_t *event) { if (cnt == 0) { log_debug(1, "sync_barrier_wait(): barrier reached"); LOCK(&bev->sctx->mutex); - locked = ISC_TRUE; + locked = true; CHECK(sync_finishev_create(bev->sctx, bev->inst, &fev)); ev = (isc_event_t *)fev; isc_task_send(ldap_instance_gettask(bev->sctx->inst), &ev); @@ -265,9 +265,9 @@ isc_result_t sync_ctx_init(isc_mem_t *mctx, ldap_instance_t *inst, sync_ctx_t **sctxp) { isc_result_t result; sync_ctx_t *sctx = NULL; - isc_boolean_t lock_ready = ISC_FALSE; - isc_boolean_t cond_ready = ISC_FALSE; - isc_boolean_t refcount_ready = ISC_FALSE; + bool lock_ready = false; + bool cond_ready = false; + bool refcount_ready = false; REQUIRE(sctxp != NULL && *sctxp == NULL); @@ -278,13 +278,13 @@ sync_ctx_init(isc_mem_t *mctx, ldap_instance_t *inst, sync_ctx_t **sctxp) { sctx->inst = inst; CHECK(isc_mutex_init(&sctx->mutex)); - lock_ready = ISC_TRUE; + lock_ready = true; CHECK(isc_condition_init(&sctx->cond)); - cond_ready = ISC_TRUE; + cond_ready = true; /* refcount includes ldap_inst->task implicitly */ CHECK(isc_refcount_init(&sctx->task_cnt, 0)); - refcount_ready = ISC_TRUE; + refcount_ready = true; ISC_LIST_INIT(sctx->tasks); @@ -297,12 +297,12 @@ sync_ctx_init(isc_mem_t *mctx, ldap_instance_t *inst, sync_ctx_t **sctxp) { return ISC_R_SUCCESS; cleanup: - if (lock_ready == ISC_TRUE) + if (lock_ready == true) DESTROYLOCK(&sctx->mutex); - if (cond_ready == ISC_TRUE) + if (cond_ready == true) RUNTIME_CHECK(isc_condition_destroy(&sctx->cond) == ISC_R_SUCCESS); - if (refcount_ready == ISC_TRUE) + if (refcount_ready == true) isc_refcount_destroy(&sctx->task_cnt); MEM_PUT_AND_DETACH(sctx); return result; @@ -357,14 +357,14 @@ sync_state_get(sync_ctx_t *sctx, sync_state_t *statep) { * support recursive mutexes in ISC mutex API. * * @warning Caller has to ensure that sctx is properly locked either externally - * or by lock = ISC_TRUE parameter. Attempt to lock sctx recursively + * or by lock = true parameter. Attempt to lock sctx recursively * will lead to deadlock. */ void -sync_state_change(sync_ctx_t *sctx, sync_state_t new_state, isc_boolean_t lock) { +sync_state_change(sync_ctx_t *sctx, sync_state_t new_state, bool lock) { REQUIRE(sctx != NULL); - if (lock == ISC_TRUE) + if (lock == true) LOCK(&sctx->mutex); switch (sctx->state) { @@ -399,7 +399,7 @@ sync_state_change(sync_ctx_t *sctx, sync_state_t new_state, isc_boolean_t lock) sctx->state = new_state; log_debug(1, "sctx state %u reached", new_state); - if (lock == ISC_TRUE) + if (lock == true) UNLOCK(&sctx->mutex); } @@ -513,7 +513,7 @@ sync_barrier_wait(sync_ctx_t *sctx, ldap_instance_t *inst) { "%u", sctx->state); } - sync_state_change(sctx, barrier_state, ISC_FALSE); + sync_state_change(sctx, barrier_state, false); for (taskel = next_taskel = HEAD(sctx->tasks); taskel != NULL; taskel = next_taskel) { @@ -553,7 +553,7 @@ sync_concurr_limit_wait(sync_ctx_t *sctx) { REQUIRE(sctx != NULL); - while (ldap_instance_isexiting(sctx->inst) == ISC_FALSE) { + while (ldap_instance_isexiting(sctx->inst) == false) { result = isc_time_nowplusinterval(&abs_timeout, &shutdown_timeout); INSIST(result == ISC_R_SUCCESS); @@ -590,22 +590,22 @@ sync_concurr_limit_signal(sync_ctx_t *sctx) { */ isc_result_t sync_event_send(sync_ctx_t *sctx, isc_task_t *task, ldap_syncreplevent_t **ev, - isc_boolean_t synchronous) { + bool synchronous) { isc_result_t result; isc_time_t abs_timeout; isc_uint32_t seqid; - isc_boolean_t locked = ISC_FALSE; + bool locked = false; REQUIRE(sctx != NULL); LOCK(&sctx->mutex); - locked = ISC_TRUE; + locked = true; /* overflow is not a problem as long as the modulo is smaller than * constant used by sync_concurr_limit_wait() */ (*ev)->seqid = seqid = ++sctx->next_id % 0xffffffff; isc_task_send(task, (isc_event_t **)ev); - while (synchronous == ISC_TRUE && sctx->last_id != seqid) { - if (ldap_instance_isexiting(sctx->inst) == ISC_TRUE) + while (synchronous == true && sctx->last_id != seqid) { + if (ldap_instance_isexiting(sctx->inst) == true) CLEANUP_WITH(ISC_R_SHUTTINGDOWN); result = isc_time_nowplusinterval(&abs_timeout, &shutdown_timeout); @@ -617,7 +617,7 @@ sync_event_send(sync_ctx_t *sctx, isc_task_t *task, ldap_syncreplevent_t **ev, result = ISC_R_SUCCESS; cleanup: - if (locked == ISC_TRUE) + if (locked == true) UNLOCK(&sctx->mutex); return result; } diff --git a/src/syncrepl.h b/src/syncrepl.h index 14684ea..d673fdf 100644 --- a/src/syncrepl.h +++ b/src/syncrepl.h @@ -40,7 +40,7 @@ void sync_state_get(sync_ctx_t *sctx, sync_state_t *statep) ATTR_NONNULLS; void -sync_state_change(sync_ctx_t *sctx, sync_state_t new_state, isc_boolean_t lock) ATTR_NONNULLS; +sync_state_change(sync_ctx_t *sctx, sync_state_t new_state, bool lock) ATTR_NONNULLS; void sync_state_reset(sync_ctx_t *sctx) ATTR_NONNULLS; @@ -59,7 +59,7 @@ sync_concurr_limit_signal(sync_ctx_t *sctx) ATTR_NONNULLS; isc_result_t sync_event_send(sync_ctx_t *sctx, isc_task_t *task, ldap_syncreplevent_t **ev, - isc_boolean_t synchronous) ATTR_NONNULLS ATTR_CHECKRESULT; + bool synchronous) ATTR_NONNULLS ATTR_CHECKRESULT; void sync_event_signal(sync_ctx_t *sctx, ldap_syncreplevent_t *ev) ATTR_NONNULLS; diff --git a/src/types.h b/src/types.h index 41ef476..28d16b5 100644 --- a/src/types.h +++ b/src/types.h @@ -5,7 +5,6 @@ #ifndef _LD_TYPES_H_ #define _LD_TYPES_H_ -#include #include #include #include diff --git a/src/util.h b/src/util.h index ab49ba9..b69c9b7 100644 --- a/src/util.h +++ b/src/util.h @@ -7,7 +7,6 @@ #include -#include #include #include #include @@ -17,7 +16,7 @@ #include "log.h" -extern isc_boolean_t verbose_checks; /* from settings.c */ +extern bool verbose_checks; /* from settings.c */ #define CLEANUP_WITH(result_code) \ do { \ @@ -29,7 +28,7 @@ extern isc_boolean_t verbose_checks; /* from settings.c */ do { \ result = (op); \ if (result != ISC_R_SUCCESS) { \ - if (verbose_checks == ISC_TRUE) \ + if (verbose_checks == true) \ log_error_position("check failed: %s", \ dns_result_totext(result)); \ goto cleanup; \ diff --git a/src/zone_register.c b/src/zone_register.c index d8525e9..2e55a07 100644 --- a/src/zone_register.c +++ b/src/zone_register.c @@ -163,7 +163,7 @@ zr_destroy(zone_register_t **zrp) if (result == ISC_R_SUCCESS) { rbt_iter_stop(&iter); result = ldap_delete_zone2(zr->ldap_inst, - &name, ISC_FALSE); + &name, false); RUNTIME_CHECK(result == ISC_R_SUCCESS); } } while (result == ISC_R_SUCCESS); @@ -221,7 +221,7 @@ zr_get_zone_path(isc_mem_t *mctx, settings_set_t *settings, isc_buffer_init(&name_buf, name_char, sizeof(name_char)); CHECK(str_new(mctx, &zone_path)); - CHECK(dns_name_tofilenametext(zone_name, ISC_TRUE, &name_buf)); + CHECK(dns_name_tofilenametext(zone_name, true, &name_buf)); INSIST(isc_buffer_usedlength(&name_buf) > 0); /* Root zone is special case: replace '.' with '@' @@ -418,7 +418,7 @@ zr_del_zone(zone_register_t *zr, dns_name_t *origin) RWLOCK(&zr->rwlock, isc_rwlocktype_write); - CHECK(dns_rbt_deletename(zr->rbt, origin, ISC_FALSE)); + CHECK(dns_rbt_deletename(zr->rbt, origin, false)); cleanup: RWUNLOCK(&zr->rwlock, isc_rwlocktype_write); @@ -601,21 +601,21 @@ delete_bind_zone(dns_zt_t *zt, dns_zone_t **zonep) { } /* Test if the existing zone is 'empty zone' per RFC 6303. */ -isc_boolean_t ATTR_NONNULLS ATTR_CHECKRESULT +bool ATTR_NONNULLS ATTR_CHECKRESULT zone_isempty(dns_zone_t *zone) { char **argv = NULL; isc_mem_t *mctx = NULL; - isc_boolean_t result = ISC_FALSE; + bool result = false; mctx = dns_zone_getmctx(zone); if (dns_zone_getdbtype(zone, &argv, mctx) != ISC_R_SUCCESS) - CLEANUP_WITH(ISC_FALSE); + CLEANUP_WITH(false); if (argv[0] != NULL && strcmp("_builtin", argv[0]) == 0 && argv[1] != NULL && strcmp("empty", argv[1]) == 0) { - result = ISC_TRUE; + result = true; } else { - result = ISC_FALSE; + result = false; } isc_mem_free(mctx, argv); diff --git a/src/zone_register.h b/src/zone_register.h index 6004078..699f8ca 100644 --- a/src/zone_register.h +++ b/src/zone_register.h @@ -57,7 +57,7 @@ zr_get_mctx(zone_register_t *zr) ATTR_NONNULLS ATTR_CHECKRESULT; isc_result_t delete_bind_zone(dns_zt_t *zt, dns_zone_t **zonep) ATTR_NONNULLS ATTR_CHECKRESULT; -isc_boolean_t +bool zone_isempty(dns_zone_t *zone) ATTR_NONNULLS ATTR_CHECKRESULT; #endif /* !_LD_ZONE_REGISTER_H_ */ From 82104f33f3271c6178662ebb93ce0186d68d1e72 Mon Sep 17 00:00:00 2001 From: Alexander Bokovoy Date: Nov 05 2019 11:46:09 +0000 Subject: [PATCH 2/3] Remove use of isc/int.h With merge commit fa03f941027cdcccc060613f773e63701b5baa77, isc/int.h is removed from BIND9. --- diff --git a/src/ldap_driver.c b/src/ldap_driver.c index 7caee83..b9161fe 100644 --- a/src/ldap_driver.c +++ b/src/ldap_driver.c @@ -669,8 +669,8 @@ transfernode(dns_db_t *db, dns_dbnode_t **sourcep, dns_dbnode_t **targetp) static isc_result_t getnsec3parameters(dns_db_t *db, dns_dbversion_t *version, - dns_hash_t *hash, isc_uint8_t *flags, - isc_uint16_t *iterations, + dns_hash_t *hash, uint8_t *flags, + uint16_t *iterations, unsigned char *salt, size_t *salt_length) { ldapdb_t *ldapdb = (ldapdb_t *) db; diff --git a/src/ldap_entry.c b/src/ldap_entry.c index 1698fd3..d0f83d4 100644 --- a/src/ldap_entry.c +++ b/src/ldap_entry.c @@ -7,7 +7,7 @@ #include #include -#include +#include #include #include #include @@ -523,7 +523,7 @@ ldap_entry_getttl(ldap_entry_t *entry, const settings_set_t * settings) isc_textregion_t ttl_text; ldap_valuelist_t values; isc_result_t result; - isc_uint32_t ttl; + uint32_t ttl; REQUIRE(entry != NULL); diff --git a/src/ldap_helper.c b/src/ldap_helper.c index 127cfcd..0a25bfb 100644 --- a/src/ldap_helper.c +++ b/src/ldap_helper.c @@ -26,7 +26,7 @@ #include #include -#include +#include #include #include #include @@ -376,7 +376,7 @@ isc_result_t validate_local_instance_settings(ldap_instance_t *inst, settings_set_t *set) { isc_result_t result; - isc_uint32_t uint; + uint32_t uint; const char *sasl_mech = NULL; const char *sasl_user = NULL; const char *sasl_realm = NULL; @@ -536,7 +536,7 @@ new_ldap_instance(isc_mem_t *mctx, const char *db_name, const char *parameters, dns_forwarders_t *named_conf_forwarders = NULL; isc_buffer_t *forwarders_list = NULL; const char *forward_policy = NULL; - isc_uint32_t connections; + uint32_t connections; char settings_name[PRINT_BUFF_SIZE]; ldap_globalfwd_handleez_t *gfwdevent = NULL; const char *server_id = NULL; @@ -1052,7 +1052,7 @@ static isc_result_t ATTR_NONNULLS ATTR_CHECKRESULT load_zone(dns_zone_t *zone, bool log) { isc_result_t result; bool zone_dynamic; - isc_uint32_t serial; + uint32_t serial; dns_zone_t *raw = NULL; result = dns_zone_load(zone); @@ -1700,9 +1700,9 @@ cleanup: */ static isc_result_t ATTR_NONNULLS ATTR_CHECKRESULT ldap_replace_serial(ldap_instance_t *inst, dns_name_t *zone, - isc_uint32_t serial) { + uint32_t serial) { isc_result_t result; -#define MAX_SERIAL_LENGTH sizeof("4294967295") /* SOA serial is isc_uint32_t */ +#define MAX_SERIAL_LENGTH sizeof("4294967295") /* SOA serial is uint32_t */ char serial_char[MAX_SERIAL_LENGTH]; char *values[2] = { serial_char, NULL }; LDAPMod change; @@ -1936,7 +1936,7 @@ zone_sync_apex(const ldap_instance_t * const inst, dns_dbversion_t * const version, const settings_set_t * const zone_settings, dns_diff_t * const diff, - isc_uint32_t * const new_serial, + uint32_t * const new_serial, bool * const ldap_writeback, bool * const data_changed) { isc_result_t result; @@ -1946,7 +1946,7 @@ zone_sync_apex(const ldap_instance_t * const inst, * This is workaround for ISC-Bug #35080. */ dns_dbnode_t *node = NULL; dns_difftuple_t *soa_tuple = NULL; - isc_uint32_t curr_serial; + uint32_t curr_serial; REQUIRE(ldap_writeback != NULL); @@ -2083,7 +2083,7 @@ ldap_parse_master_zoneentry(ldap_entry_t * const entry, dns_db_t * const olddb, settings_set_t *zone_settings = NULL; bool ldap_writeback; bool data_changed = false; /* GCC */ - isc_uint32_t new_serial; + uint32_t new_serial; dns_db_t *rbtdb = NULL; dns_db_t *ldapdb = NULL; @@ -2761,7 +2761,7 @@ ldap_connect(ldap_instance_t *ldap_inst, ldap_connection_t *ldap_conn, isc_result_t result = ISC_R_FAILURE; const char *uri = NULL; const char *ldap_hostname = NULL; - isc_uint32_t timeout_sec; + uint32_t timeout_sec; REQUIRE(ldap_inst != NULL); REQUIRE(ldap_conn != NULL); @@ -2827,7 +2827,7 @@ ldap_reconnect(ldap_instance_t *ldap_inst, ldap_connection_t *ldap_conn, const char *krb5_principal = NULL; const char *krb5_keytab = NULL; ldap_auth_t auth_method_enum = AUTH_INVALID; - isc_uint32_t reconnect_interval; + uint32_t reconnect_interval; if (force) goto force_reconnect; @@ -3324,7 +3324,7 @@ modify_soa_record(ldap_instance_t *ldap_inst, const char *zone_dn, REQUIRE(ldap_inst != NULL); -/* all values in SOA record are isc_uint32_t, i.e. max. 2^32-1 */ +/* all values in SOA record are uint32_t, i.e. max. 2^32-1 */ #define MAX_SOANUM_LENGTH (10 + 1) #define SET_LDAP_MOD(index, name) \ change[index].mod_op = LDAP_MOD_REPLACE; \ @@ -3837,7 +3837,7 @@ update_record(isc_task_t *task, isc_event_t *event) dns_zone_t *secure = NULL; bool zone_found = false; bool zone_reloaded = false; - isc_uint32_t serial; + uint32_t serial; ldap_entry_t *entry = pevent->entry; dns_db_t *rbtdb = NULL; @@ -4680,7 +4680,7 @@ ldap_syncrepl_watcher(isc_threadarg_t arg) int ret; isc_result_t result; sigset_t sigset; - isc_uint32_t reconnect_interval; + uint32_t reconnect_interval; sync_state_t state; log_debug(1, "Entering ldap_syncrepl_watcher"); diff --git a/src/mldap.c b/src/mldap.c index a6e5971..51df185 100644 --- a/src/mldap.c +++ b/src/mldap.c @@ -9,7 +9,7 @@ #include #include -#include +#include #include #include #include @@ -111,20 +111,20 @@ void mldap_cur_generation_bump(mldapdb_t *mldap) { } /* - * Verify that isc_refcount_t can be casted properly to isc_uint32_t + * Verify that isc_refcount_t can be casted properly to uint32_t * so isc_serial_* functions can be safely used for comparison. * * The spell 'typeof(isc_refcount_current((isc_refcount_t *)0))' walks through * isc_refcount_t abstractions and returns underlying type used for storing the * reference counter value. */ -STATIC_ASSERT((isc_uint32_t) +STATIC_ASSERT((uint32_t) (typeof(((isc_refcount_t *)0)->refs)) -1 == 0xFFFFFFFF, \ "negative isc_refcount_t cannot be properly shortened to 32 bits"); -STATIC_ASSERT((isc_uint32_t) +STATIC_ASSERT((uint32_t) (typeof(((isc_refcount_t *)0)->refs)) 0x90ABCDEF12345678 == 0x12345678, \ @@ -135,9 +135,9 @@ STATIC_ASSERT((isc_uint32_t) * * Generation numbers have to be compared using isc_serial_* functions. */ -isc_uint32_t +uint32_t mldap_cur_generation_get(mldapdb_t *mldap) { - return (isc_uint32_t)isc_refcount_current(&mldap->generation); + return (uint32_t)isc_refcount_current(&mldap->generation); } /** @@ -230,7 +230,7 @@ mldap_generation_store(mldapdb_t *mldap, metadb_node_t *node) { unsigned char buff[sizeof(mldap->generation)]; isc_region_t region = { .base = buff, .length = sizeof(buff) }; dns_rdata_t rdata; - isc_uint32_t generation; + uint32_t generation; STATIC_ASSERT(sizeof(mldap_cur_generation_get(mldap)) == sizeof(struct in_addr), \ "mldapdb_t->generation value is too big for A rdata type"); @@ -251,7 +251,7 @@ cleanup: } static isc_result_t -mldap_generation_get(metadb_node_t *node, isc_uint32_t *generationp) { +mldap_generation_get(metadb_node_t *node, uint32_t *generationp) { isc_result_t result; dns_rdataset_t rdataset; dns_rdata_t rdata; @@ -430,14 +430,14 @@ mldap_iter_deadnodes_start(mldapdb_t *mldap, metadb_iter_t **iterp, REQUIRE(iterp != NULL && *iterp == NULL); CHECK(metadb_iterator_create(mldap->mdb, &iter)); - CHECKED_MEM_GET(mldap->mctx, iter->state, sizeof(isc_uint32_t)); + CHECKED_MEM_GET(mldap->mctx, iter->state, sizeof(uint32_t)); result = dns_dbiterator_seek(iter->iter, &uuid_rootname); if (result == ISC_R_NOTFOUND) /* metaLDAP is empty */ CLEANUP_WITH(ISC_R_NOMORE); else if (result != ISC_R_SUCCESS) goto cleanup; /* store current generation value for sanity checking */ - *(isc_uint32_t *)iter->state = mldap_cur_generation_get(mldap); + *(uint32_t *)iter->state = mldap_cur_generation_get(mldap); CHECK(mldap_iter_deadnodes_next(mldap, &iter, uuid)); @@ -446,7 +446,7 @@ mldap_iter_deadnodes_start(mldapdb_t *mldap, metadb_iter_t **iterp, cleanup: if (iter != NULL) { - SAFE_MEM_PUT(mldap->mctx, iter->state, sizeof(isc_uint32_t)); + SAFE_MEM_PUT(mldap->mctx, iter->state, sizeof(uint32_t)); iter->state = NULL; metadb_iterator_destroy(&iter); } @@ -478,8 +478,8 @@ mldap_iter_deadnodes_next(mldapdb_t *mldap, metadb_iter_t **iterp, isc_result_t result; dns_dbnode_t *rbt_node = NULL; metadb_iter_t *iter = NULL; - isc_uint32_t node_generation; - isc_uint32_t cur_generation; + uint32_t node_generation; + uint32_t cur_generation; metadb_node_t metadb_node; DECLARE_BUFFERED_NAME(name); isc_region_t name_region; @@ -511,7 +511,7 @@ mldap_iter_deadnodes_next(mldapdb_t *mldap, metadb_iter_t **iterp, == ISC_R_SUCCESS); cur_generation = mldap_cur_generation_get(mldap); /* sanity check: generation number cannot change during iteration */ - INSIST(*(isc_uint32_t *)(*iterp)->state == cur_generation); + INSIST(*(uint32_t *)(*iterp)->state == cur_generation); if (isc_serial_lt(node_generation, cur_generation)) break; /* this node is from previous mLDAP generation */ @@ -531,7 +531,7 @@ cleanup: if (rbt_node != NULL) dns_db_detachnode(iter->rbtdb, &rbt_node); if (result != ISC_R_SUCCESS) { - SAFE_MEM_PUT(iter->mctx, iter->state, sizeof(isc_uint32_t)); + SAFE_MEM_PUT(iter->mctx, iter->state, sizeof(uint32_t)); iter->state = NULL; metadb_iterator_destroy(iterp); } diff --git a/src/mldap.h b/src/mldap.h index ee04403..c5ef555 100644 --- a/src/mldap.h +++ b/src/mldap.h @@ -45,7 +45,7 @@ mldap_dnsname_store(dns_name_t *fqdn, dns_name_t *zone, metadb_node_t *node); void ATTR_NONNULLS mldap_cur_generation_bump(mldapdb_t *mldap); -isc_uint32_t ATTR_CHECKRESULT ATTR_NONNULLS +uint32_t ATTR_CHECKRESULT ATTR_NONNULLS mldap_cur_generation_get(mldapdb_t *mldap); isc_result_t ATTR_CHECKRESULT ATTR_NONNULLS diff --git a/src/settings.c b/src/settings.c index 451f63e..90c7e47 100644 --- a/src/settings.c +++ b/src/settings.c @@ -7,7 +7,7 @@ #include #include #include -#include +#include #include #include @@ -160,7 +160,7 @@ setting_get(const char *const name, const setting_type_t type, switch (type) { case ST_UNSIGNED_INTEGER: - *(isc_uint32_t *)target = setting->value.value_uint; + *(uint32_t *)target = setting->value.value_uint; break; case ST_STRING: *(char **)target = setting->value.value_char; @@ -183,7 +183,7 @@ cleanup: isc_result_t setting_get_uint(const char *const name, const settings_set_t *const set, - isc_uint32_t *target) + uint32_t *target) { return setting_get(name, ST_UNSIGNED_INTEGER, set, target); } @@ -217,8 +217,8 @@ set_value(isc_mem_t *mctx, const settings_set_t *set, setting_t *setting, const char *value) { isc_result_t result; - isc_uint32_t numeric_value; - isc_uint32_t len; + uint32_t numeric_value; + uint32_t len; REQUIRE(setting != NULL); REQUIRE(value != NULL); diff --git a/src/settings.h b/src/settings.h index 724deb0..572b7fe 100644 --- a/src/settings.h +++ b/src/settings.h @@ -6,7 +6,7 @@ #define _LD_SETTINGS_H_ #include -#include +#include #include @@ -33,7 +33,7 @@ struct setting { setting_type_t type; union { char *value_char; - isc_uint32_t value_uint; + uint32_t value_uint; bool value_boolean; } value; bool filled; @@ -99,7 +99,7 @@ setting_find(const char *name, const settings_set_t *set, isc_result_t setting_get_uint(const char * const name, const settings_set_t * const set, - isc_uint32_t * target) ATTR_NONNULLS ATTR_CHECKRESULT; + uint32_t * target) ATTR_NONNULLS ATTR_CHECKRESULT; isc_result_t setting_get_str(const char * const name, const settings_set_t * const set, diff --git a/src/syncrepl.c b/src/syncrepl.c index 8bb340a..054d625 100644 --- a/src/syncrepl.c +++ b/src/syncrepl.c @@ -93,8 +93,8 @@ struct sync_ctx { ISC_LIST(task_element_t) tasks; /**< list of tasks processing events from initial synchronization phase */ - isc_uint32_t next_id; /**< next sequential id */ - isc_uint32_t last_id; /**< last processed event */ + uint32_t next_id; /**< next sequential id */ + uint32_t last_id; /**< last processed event */ }; /** @@ -202,7 +202,7 @@ barrier_decrement(isc_task_t *task, isc_event_t *event) { sync_barrierev_t *bev = NULL; sync_barrierev_t *fev = NULL; isc_event_t *ev = NULL; - isc_uint32_t cnt; + uint32_t cnt; bool locked = false; REQUIRE(ISCAPI_TASK_VALID(task)); @@ -445,7 +445,7 @@ sync_state_reset(sync_ctx_t *sctx) { isc_result_t sync_task_add(sync_ctx_t *sctx, isc_task_t *task) { isc_result_t result = ISC_R_SUCCESS; - isc_uint32_t cnt; + uint32_t cnt; task_element_t *newel = NULL; REQUIRE(sctx != NULL); @@ -593,7 +593,7 @@ sync_event_send(sync_ctx_t *sctx, isc_task_t *task, ldap_syncreplevent_t **ev, bool synchronous) { isc_result_t result; isc_time_t abs_timeout; - isc_uint32_t seqid; + uint32_t seqid; bool locked = false; REQUIRE(sctx != NULL); diff --git a/src/types.h b/src/types.h index 28d16b5..f5c7957 100644 --- a/src/types.h +++ b/src/types.h @@ -6,7 +6,7 @@ #define _LD_TYPES_H_ #include -#include +#include #include #include @@ -48,7 +48,7 @@ struct ldap_syncreplevent { char *prevdn; int chgtype; ldap_entry_t *entry; - isc_uint32_t seqid; + uint32_t seqid; }; #endif /* !_LD_TYPES_H_ */ diff --git a/src/zone.c b/src/zone.c index b9c9936..d0b71b1 100644 --- a/src/zone.c +++ b/src/zone.c @@ -2,7 +2,7 @@ * Copyright (C) 2014-2015 bind-dyndb-ldap authors; see COPYING for license */ -#include +#include #include #include @@ -52,8 +52,8 @@ cleanup: */ isc_result_t ATTR_NONNULL(2) ATTR_CHECKRESULT zone_soaserial_updatetuple(dns_updatemethod_t method, dns_difftuple_t *soa_tuple, - isc_uint32_t *new_serial) { - isc_uint32_t serial; + uint32_t *new_serial) { + uint32_t serial; REQUIRE(DNS_DIFFTUPLE_VALID(soa_tuple)); REQUIRE(soa_tuple->op == DNS_DIFFOP_ADD || @@ -80,7 +80,7 @@ zone_soaserial_updatetuple(dns_updatemethod_t method, dns_difftuple_t *soa_tuple isc_result_t ATTR_NONNULL(1,2,3,4) ATTR_CHECKRESULT zone_soaserial_addtuple(isc_mem_t *mctx, dns_db_t *db, dns_dbversion_t *version, dns_diff_t *diff, - isc_uint32_t *new_serial) { + uint32_t *new_serial) { isc_result_t result; dns_difftuple_t *del = NULL; dns_difftuple_t *add = NULL; diff --git a/src/zone.h b/src/zone.h index 87556f8..a99aa5c 100644 --- a/src/zone.h +++ b/src/zone.h @@ -5,7 +5,7 @@ #ifndef SRC_ZONE_H_ #define SRC_ZONE_H_ -#include +#include #include #include @@ -19,12 +19,12 @@ zone_journal_adddiff(isc_mem_t *mctx, dns_zone_t *zone, dns_diff_t *diff); isc_result_t ATTR_NONNULL(2) ATTR_CHECKRESULT zone_soaserial_updatetuple(dns_updatemethod_t method, dns_difftuple_t *soa_tuple, - isc_uint32_t *new_serial); + uint32_t *new_serial); isc_result_t ATTR_NONNULL(1,2,3,4) ATTR_CHECKRESULT zone_soaserial_addtuple(isc_mem_t *mctx, dns_db_t *db, dns_dbversion_t *version, dns_diff_t *diff, - isc_uint32_t *new_serial); + uint32_t *new_serial); isc_result_t ATTR_NONNULLS ATTR_CHECKRESULT rdatalist_to_diff(isc_mem_t *mctx, dns_diffop_t op, dns_name_t *name, From 88e4fa14f46f3b8c3c0969a57131f17a23463a47 Mon Sep 17 00:00:00 2001 From: Alexander Bokovoy Date: Nov 05 2019 11:48:54 +0000 Subject: [PATCH 3/3] Remove unused header reference for isc/md5.h --- diff --git a/src/zone_register.c b/src/zone_register.c index 2e55a07..96373cc 100644 --- a/src/zone_register.c +++ b/src/zone_register.c @@ -5,7 +5,6 @@ #include #include #include -#include #include #include