Sisyphus repositório
Última atualização: 16 setembro 2019 | SRPMs: 17434 | Visitas: 15105722
en ru br
ALT Linux repositórios
S:11.1-alt7

Group :: Sistema/Servidores
RPM: bind-dyndb-ldap

 Main   Changelog   Spec   Patches   Sources   Download   Gear   Bugs e FR  Repocop 

Patch: bind-dyndb-ldap-11.1-alt.patch
Download


 src/acl.c           |  10 +-
 src/bindcfg.c       |   1 +
 src/empty_zones.c   |  16 +--
 src/empty_zones.h   |   4 +-
 src/fwd.c           |  40 +++---
 src/fwd_register.c  |   3 +-
 src/ldap_convert.c  |  22 +--
 src/ldap_convert.h  |   6 +-
 src/ldap_driver.c   |  49 +++----
 src/ldap_entry.c    |   8 +-
 src/ldap_entry.h    |  11 +-
 src/ldap_helper.c   | 383 ++++++++++++++++++++++++++--------------------------
 src/ldap_helper.h   |   8 +-
 src/metadb.c        |  30 ++--
 src/metadb.h        |   2 +-
 src/mldap.c         |  38 +++---
 src/mldap.h         |   4 +-
 src/rbt_helper.c    |   1 +
 src/settings.c      |  54 ++++----
 src/settings.h      |  28 ++--
 src/syncptr.c       |  32 ++---
 src/syncrepl.c      |  58 ++++----
 src/syncrepl.h      |   4 +-
 src/types.h         |   4 +-
 src/util.h          |   4 +-
 src/zone.c          |   6 +-
 src/zone.h          |   4 +-
 src/zone_register.c |  16 +--
 src/zone_register.h |   2 +-
 29 files changed, 425 insertions(+), 423 deletions(-)
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/bindcfg.c b/src/bindcfg.c
index 9b429ba..5539dea 100644
--- a/src/bindcfg.c
+++ b/src/bindcfg.c
@@ -6,6 +6,7 @@
 
 #include "config.h"
 
+#include <isc/util.h>
 #include <isccfg/grammar.h>
 #include <isccfg/namedconf.h>
 
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 840f0e8..7ac381b 100644
--- a/src/fwd.c
+++ b/src/fwd.c
@@ -306,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;
@@ -323,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:
@@ -354,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);
 
@@ -363,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);
 		}
@@ -434,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));
@@ -501,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;
@@ -513,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);
@@ -524,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)";
@@ -541,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);
@@ -554,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);
@@ -578,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));
 	}
@@ -590,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)));
@@ -632,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,
@@ -644,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 355d15f..06a4d92 100644
--- a/src/fwd_register.c
+++ b/src/fwd_register.c
@@ -3,6 +3,7 @@
  */
 
 #include <isc/rwlock.h>
+#include <isc/util.h>
 #include <dns/name.h>
 
 #include "rbt_helper.h"
@@ -100,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 002a679..3464dd5 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",
@@ -406,12 +406,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 47ac947..4190df2 100644
--- a/src/ldap_convert.h
+++ b/src/ldap_convert.h
@@ -26,11 +26,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,
@@ -41,7 +41,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 53ce1a9..b9161fe 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;
 
@@ -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;
@@ -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;
@@ -867,7 +867,8 @@ static dns_dbmethods_t ldapdb_methods = {
 	findext,
 	setcachestats,
 	hashsize,
-	nodefullname
+	nodefullname,
+	NULL, // getsize method not implemented (related BZ1353563)
 };
 
 isc_result_t ATTR_NONNULLS
@@ -949,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);
@@ -962,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);
 
@@ -987,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 96a6ef8..909ab1f 100644
--- a/src/ldap_entry.c
+++ b/src/ldap_entry.c
@@ -189,8 +189,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);
@@ -234,7 +234,7 @@ 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_dn = false;
 	has_zone_class = ISC_TF(entry->class & (LDAP_ENTRYCLASS_MASTER
 						| LDAP_ENTRYCLASS_FORWARD));
 	CHECK(dn_want_zone(__func__, entry->dn, has_zone_dn, has_zone_class));
@@ -522,7 +522,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_entry.h b/src/ldap_entry.h
index 6498c79..88b1c42 100644
--- a/src/ldap_entry.h
+++ b/src/ldap_entry.h
@@ -6,7 +6,6 @@
 #define _LD_LDAP_ENTRY_H_
 
 #include <isc/lex.h>
-#include <isc/util.h>
 #include <dns/types.h>
 
 #include "fwd_register.h"
@@ -19,15 +18,15 @@
 
 /* Represents values associated with LDAP attribute */
 typedef struct ldap_value ldap_value_t;
-typedef LIST(ldap_value_t) ldap_valuelist_t;
+typedef ISC_LIST(ldap_value_t) ldap_valuelist_t;
 struct ldap_value {
         char                    *value;
-        LINK(ldap_value_t)      link;
+        ISC_LINK(ldap_value_t)      link;
 };
 
 /* Represents LDAP attribute and it's values */
 typedef struct ldap_attribute	ldap_attribute_t;
-typedef LIST(ldap_attribute_t)	ldap_attributelist_t;
+typedef ISC_LIST(ldap_attribute_t)	ldap_attributelist_t;
 
 /* Represents LDAP entry and it's attributes */
 typedef unsigned char		ldap_entryclass_t;
@@ -41,7 +40,7 @@ struct ldap_entry {
 
 	ldap_attribute_t	*lastattr;
 	ldap_attributelist_t	attrs;
-	LINK(ldap_entry_t)	link;
+	ISC_LINK(ldap_entry_t)	link;
 
 	/* Parsing. */
 	isc_lex_t		*lex;
@@ -59,7 +58,7 @@ struct ldap_attribute {
 	char			**ldap_values;
 	ldap_value_t		*lastval;
 	ldap_valuelist_t	values;
-	LINK(ldap_attribute_t)	link;
+	ISC_LINK(ldap_attribute_t)	link;
 };
 
 #define LDAP_ENTRYCLASS_NONE	0x0
diff --git a/src/ldap_helper.c b/src/ldap_helper.c
index 1fa0ec9..446c85f 100644
--- a/src/ldap_helper.c
+++ b/src/ldap_helper.c
@@ -150,7 +150,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;
 
@@ -328,28 +328,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,
@@ -375,7 +375,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;
@@ -384,7 +384,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;
@@ -399,7 +399,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
@@ -512,7 +512,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:
@@ -535,7 +535,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;
@@ -621,7 +621,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 */
@@ -699,7 +699,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
@@ -820,7 +820,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;
@@ -852,11 +852,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;
@@ -911,7 +911,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)
@@ -932,7 +932,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;
@@ -941,7 +941,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/",
@@ -964,7 +964,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;
@@ -991,9 +991,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 {
@@ -1005,8 +1005,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));
 	}
 
@@ -1048,10 +1048,10 @@ 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;
-	isc_uint32_t serial;
+	bool zone_dynamic;
+	uint32_t serial;
 	dns_zone_t *raw = NULL;
 
 	result = dns_zone_load(zone);
@@ -1067,16 +1067,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;
@@ -1100,7 +1100,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;
@@ -1140,7 +1140,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);
 	}
 
@@ -1188,7 +1188,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));
@@ -1217,7 +1217,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);
@@ -1230,7 +1230,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)
@@ -1337,12 +1337,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;
@@ -1379,7 +1379,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 */
 
@@ -1413,13 +1413,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));
@@ -1536,7 +1536,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;
 	}
 
@@ -1620,14 +1620,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 */
@@ -1638,13 +1638,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) {
@@ -1659,8 +1659,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));
@@ -1699,9 +1699,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;
@@ -1718,7 +1718,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);
@@ -1753,7 +1753,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) {
@@ -1777,7 +1777,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);
@@ -1816,7 +1816,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));
@@ -1885,7 +1885,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));
@@ -1903,8 +1903,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:
@@ -1922,7 +1922,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.
  *
@@ -1930,14 +1930,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) {
+	       uint32_t * const new_serial,
+	       bool * const ldap_writeback,
+	       bool * const data_changed) {
 	isc_result_t result;
 	ldapdb_rdatalist_t rdatalist;
 	dns_rdatasetiter_t *rbt_rds_iterator = NULL;
@@ -1945,12 +1945,12 @@ 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);
 
 	INIT_LIST(rdatalist);
-	*ldap_writeback = ISC_FALSE; /* GCC */
+	*ldap_writeback = false; /* GCC */
 
 	CHECK(ldap_parse_rrentry(inst->mctx, entry, &name,
 				 zone_settings, &rdatalist));
@@ -1966,37 +1966,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));
@@ -2038,7 +2038,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:
@@ -2074,15 +2074,15 @@ 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 */
-	isc_uint32_t new_serial;
+	bool ldap_writeback;
+	bool data_changed = false; /* GCC */
+	uint32_t new_serial;
 
 	dns_db_t *rbtdb = NULL;
 	dns_db_t *ldapdb = NULL;
@@ -2100,7 +2100,7 @@ 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);
@@ -2111,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)
+		if (want_secure == true)
 			dns_zone_log(raw, ISC_LOG_INFO,
 				     "upgrading zone to secure");
 		else
@@ -2149,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);
@@ -2160,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));
@@ -2192,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" */
@@ -2211,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));
@@ -2392,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(3, "setting '%s' is not defined so it "
 				  "cannot be substituted into template '%s'",
@@ -2457,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;
 	static const char prefix[] = "idnsTemplateAttribute;";
 	static const char prefix_len = sizeof(prefix) - 1;
 
@@ -2493,7 +2493,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;
 		}
 	}
 
@@ -2745,7 +2745,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;
@@ -2754,7 +2754,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);
@@ -2809,7 +2809,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;
@@ -2820,7 +2820,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;
@@ -2943,7 +2943,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;
@@ -2981,7 +2981,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)
@@ -3003,12 +3003,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;
 
@@ -3037,8 +3037,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) {
@@ -3101,7 +3101,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;
@@ -3163,7 +3163,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;
@@ -3190,12 +3190,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;
@@ -3223,7 +3223,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));
@@ -3317,7 +3317,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; \
@@ -3338,7 +3338,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;
@@ -3349,19 +3349,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.
@@ -3380,7 +3380,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);
@@ -3407,7 +3407,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],
@@ -3415,7 +3415,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) {
@@ -3459,12 +3459,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);
@@ -3481,7 +3481,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));
@@ -3495,10 +3495,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]);
@@ -3525,7 +3525,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;
@@ -3661,7 +3661,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) {
@@ -3714,10 +3714,11 @@ update_zone(isc_task_t *task, isc_event_t *event)
 	mctx = pevent->mctx;
 	dns_name_init(&prevname, NULL);
 
+	REQUIRE(inst != NULL);
 	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,
@@ -3730,12 +3731,11 @@ update_zone(isc_task_t *task, isc_event_t *event)
 	}
 
 cleanup:
-	if (inst != NULL) {
-		sync_concurr_limit_signal(inst->sctx);
-		sync_event_signal(inst->sctx, pevent);
-		if (dns_name_dynamic(&prevname))
-			dns_name_free(&prevname, inst->mctx);
-	}
+	sync_concurr_limit_signal(inst->sctx);
+	sync_event_signal(inst->sctx, pevent);
+	if (dns_name_dynamic(&prevname))
+		dns_name_free(&prevname, inst->mctx);
+
 	if (result != ISC_R_SUCCESS)
 		log_error_r("update_zone (syncrepl) failed for %s. "
 			    "Zones can be outdated, run `rndc reload`",
@@ -3760,14 +3760,14 @@ update_config(isc_task_t * task, isc_event_t *event)
 
 	mctx = pevent->mctx;
 
+	REQUIRE(inst != NULL);
 	INSIST(task == inst->task); /* For task-exclusive mode */
 	CHECK(ldap_parse_configentry(entry, inst));
 
 cleanup:
-	if (inst != NULL) {
-		sync_concurr_limit_signal(inst->sctx);
-		sync_event_signal(inst->sctx, pevent);
-	}
+	sync_concurr_limit_signal(inst->sctx);
+	sync_event_signal(inst->sctx, pevent);
+
 	if (result != ISC_R_SUCCESS)
 		log_error_r("update_config (syncrepl) failed for %s. "
 			    "Configuration can be outdated, run `rndc reload`",
@@ -3790,14 +3790,14 @@ update_serverconfig(isc_task_t * task, isc_event_t *event)
 
 	mctx = pevent->mctx;
 
+	REQUIRE(inst != NULL);
 	INSIST(task == inst->task); /* For task-exclusive mode */
 	CHECK(ldap_parse_serverconfigentry(entry, inst));
 
 cleanup:
-	if (inst != NULL) {
-		sync_concurr_limit_signal(inst->sctx);
-		sync_event_signal(inst->sctx, pevent);
-	}
+	sync_concurr_limit_signal(inst->sctx);
+	sync_event_signal(inst->sctx, pevent);
+
 	if (result != ISC_R_SUCCESS)
 		log_error_r("update_serverconfig (syncrepl) failed for %s. "
 			    "Configuration can be outdated, run `rndc reload`",
@@ -3828,9 +3828,9 @@ 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;
-	isc_uint32_t serial;
+	bool zone_found = false;
+	bool zone_reloaded = false;
+	uint32_t serial;
 	ldap_entry_t *entry = pevent->entry;
 
 	dns_db_t *rbtdb = NULL;
@@ -3860,8 +3860,9 @@ update_record(isc_task_t *task, isc_event_t *event)
 	dns_name_init(&prevname, NULL);
 	dns_name_init(&prevorigin, NULL);
 
+	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;
@@ -3871,7 +3872,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;
@@ -3958,7 +3959,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);
 	}
 
@@ -3980,7 +3981,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)
@@ -3992,16 +3993,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;
@@ -4020,13 +4021,12 @@ cleanup:
 			    ldap_entry_logname(entry), pevent->chgtype);
 	}
 
-	if (inst != NULL) {
-		sync_concurr_limit_signal(inst->sctx);
-		if (dns_name_dynamic(&prevname))
-			dns_name_free(&prevname, inst->mctx);
-		if (dns_name_dynamic(&prevorigin))
-			dns_name_free(&prevorigin, inst->mctx);
-	}
+	sync_concurr_limit_signal(inst->sctx);
+	if (dns_name_dynamic(&prevname))
+		dns_name_free(&prevname, inst->mctx);
+	if (dns_name_dynamic(&prevorigin))
+		dns_name_free(&prevorigin, inst->mctx);
+
 	if (raw != NULL)
 		dns_zone_detach(&raw);
 	if (secure != NULL)
@@ -4042,7 +4042,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;
@@ -4101,10 +4101,9 @@ syncrepl_update(ldap_instance_t *inst, ldap_entry_t **entryp, int chgtype)
 	ldap_entry_t *entry = NULL;
 	dns_name_t *zone_name = NULL;
 	dns_zone_t *zone_ptr = NULL;
-	char *dn = NULL;
 	isc_taskaction_t action = NULL;
 	isc_task_t *task = NULL;
-	isc_boolean_t synchronous;
+	bool synchronous;
 
 	REQUIRE(entryp != NULL);
 	entry = *entryp;
@@ -4127,12 +4126,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);
 
@@ -4154,7 +4153,7 @@ syncrepl_update(ldap_instance_t *inst, ldap_entry_t **entryp, int chgtype)
 	else if ((entry->class & LDAP_ENTRYCLASS_RR) != 0)
 		action = update_record;
 	else {
-		log_error("unsupported objectClass: dn '%s'", dn);
+		log_error("unsupported objectClass: dn '%s'", entry->dn);
 		result = ISC_R_NOTIMPLEMENTED;
 		goto cleanup;
 	}
@@ -4208,9 +4207,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;
@@ -4221,7 +4220,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 */
@@ -4237,7 +4236,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;
@@ -4251,7 +4250,7 @@ install_usr1handler(void)
 	/* Don't attempt to replace already existing handler */
 	RUNTIME_CHECK(oldsa.sa_handler == NULL);
 
-	once = ISC_TRUE;
+	once = true;
 }
 
 /*
@@ -4288,8 +4287,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;
@@ -4299,7 +4298,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);
@@ -4327,7 +4326,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));
@@ -4338,7 +4337,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));
@@ -4353,11 +4352,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 &&
@@ -4374,7 +4373,7 @@ 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));
 	if (result != ISC_R_SUCCESS) {
@@ -4673,7 +4672,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");
@@ -4709,7 +4708,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;
@@ -4748,7 +4747,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);
 		}
 
 	}
@@ -4802,7 +4801,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;
@@ -4817,7 +4816,7 @@ 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);
 }
diff --git a/src/ldap_helper.h b/src/ldap_helper.h
index 6cfece5..6ac6282 100644
--- a/src/ldap_helper.h
+++ b/src/ldap_helper.h
@@ -47,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. */
@@ -56,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,
@@ -71,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);
@@ -88,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 143abce..8c670da 100644
--- a/src/mldap.c
+++ b/src/mldap.c
@@ -97,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);
 }
 
@@ -111,21 +111,21 @@ 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)
-		(typeof(isc_refcount_current((isc_refcount_t *)0)))
+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)
-		(typeof(isc_refcount_current((isc_refcount_t *)0)))
+STATIC_ASSERT((uint32_t)
+		(typeof(((isc_refcount_t *)0)->refs))
 		0x90ABCDEF12345678
 	      == 0x12345678, \
 	      "positive isc_refcount_t cannot be properly shortened to 32 bits");
@@ -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;
@@ -496,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;
 
@@ -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 c682d48..c5ef555 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);
@@ -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/rbt_helper.c b/src/rbt_helper.c
index 2a7e6cb..f610b07 100644
--- a/src/rbt_helper.c
+++ b/src/rbt_helper.c
@@ -2,6 +2,7 @@
  * Copyright (C) 2013-2014  bind-dyndb-ldap authors; see COPYING for license
  */
 
+#include <isc/util.h>
 #include <dns/rbt.h>
 
 #include "util.h"
diff --git a/src/settings.c b/src/settings.c
index 37e6e5c..e61953c 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[] = {
@@ -51,8 +51,8 @@ static const setting_t settings_default[] = {
 	{ "fake_mname",			default_string("")		},
 	{ "psearch",			default_string("")		}, /* No longer supported */
 	{ "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.
@@ -61,7 +61,7 @@ static const setting_t settings_default[] = {
 	 * dns_ssutable_checkrules() will return deny. */
 	{ "update_policy",		default_string("")		},
 	{ "serial_autoincrement",	default_string("")		},
-	{ "verbose_checks",		default_boolean(ISC_FALSE)	},
+	{ "verbose_checks",		default_boolean(false)	},
 	{ "directory",			default_string("")		},
 	{ "server_id",			default_string("")		},
 	end_of_settings
@@ -91,7 +91,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);
@@ -154,7 +154,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 "
@@ -164,13 +164,13 @@ 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;
 		break;
 	case ST_BOOLEAN:
-		*(isc_boolean_t *)target = setting->value.value_boolean;
+		*(bool *)target = setting->value.value_boolean;
 		break;
 	default:
 		UNEXPECTED_ERROR(__FILE__, __LINE__,
@@ -187,7 +187,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);
 }
@@ -201,7 +201,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);
 }
@@ -221,8 +221,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);
@@ -284,7 +284,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;
 
@@ -332,7 +332,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);
 
@@ -363,7 +363,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;
@@ -374,7 +374,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:
@@ -415,7 +415,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));
@@ -563,7 +563,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);
 }
@@ -587,10 +587,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;
@@ -629,23 +629,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;
@@ -680,7 +680,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 16a1e63..da25b1c 100644
--- a/src/settings.h
+++ b/src/settings.h
@@ -32,11 +32,11 @@ struct setting {
 	setting_type_t	type;
 	union {
 		char		*value_char;
-		isc_uint32_t	value_uint;
-		isc_boolean_t	value_boolean;
+		uint32_t	value_uint;
+		bool	value_boolean;
 	} value;
-	isc_boolean_t	filled;
-	isc_boolean_t	is_dynamic;
+	bool	filled;
+	bool	is_dynamic;
 };
 
 struct settings_set {
@@ -59,13 +59,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) }
@@ -88,17 +88,17 @@ 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
 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,
@@ -106,7 +106,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..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 */
 };
 
 /**
@@ -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)
@@ -202,8 +202,8 @@ 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;
-	isc_boolean_t locked = ISC_FALSE;
+	uint32_t cnt;
+	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);
 }
 
@@ -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);
@@ -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;
+	uint32_t seqid;
+	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 25ef3b9..f6a6649 100644
--- a/src/types.h
+++ b/src/types.h
@@ -24,7 +24,7 @@
  * rdata1 -> rdata2 -> rdata3           rdata4 -> rdata5
  * next_rdatalist              ->       next_rdatalist  ...
  */
-typedef LIST(dns_rdatalist_t) ldapdb_rdatalist_t;
+typedef ISC_LIST(dns_rdatalist_t) ldapdb_rdatalist_t;
 
 typedef struct enum_txt_assoc {
 	int		value;
@@ -47,7 +47,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/util.h b/src/util.h
index ab49ba9..766b7ee 100644
--- a/src/util.h
+++ b/src/util.h
@@ -17,7 +17,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 +29,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.c b/src/zone.c
index 284136e..aa8fcb4 100644
--- a/src/zone.c
+++ b/src/zone.c
@@ -51,8 +51,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 ||
@@ -79,7 +79,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..bc55534 100644
--- a/src/zone.h
+++ b/src/zone.h
@@ -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,
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_ */
 
projeto & código: Vladimir Lettiev aka crux © 2004-2005, Andrew Avramenko aka liks © 2007-2008
mantenedor atual: Michael Shigorin
mantenedor da tradução: Fernando Martini aka fmartini © 2009