From: Mark Andrews <marka@isc.org>
Date: Thu, 18 Sep 2025 12:33:36 +0000 (+0200)
Subject: Rename isc_result_t ret; to isc_result_t result;
X-Git-Tag: v9.21.16~3^2~4
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=0e230c86d2d7b64b7157e50723e93d6c2a59afe5;p=thirdparty%2Fbind9.git

Rename isc_result_t ret; to isc_result_t result;

Standardize result variable naming by using 'result' in most places.
---

diff --git a/bin/dnssec/dnssec-keyfromlabel.c b/bin/dnssec/dnssec-keyfromlabel.c
index 9245fb7ceff..288b7fc85d0 100644
--- a/bin/dnssec/dnssec-keyfromlabel.c
+++ b/bin/dnssec/dnssec-keyfromlabel.c
@@ -116,7 +116,7 @@ main(int argc, char **argv) {
 	dst_algorithm_t alg;
 	bool oldstyle = false;
 	int ch;
-	isc_result_t ret;
+	isc_result_t result;
 	isc_textregion_t r;
 	char filename[255];
 	isc_buffer_t buf;
@@ -182,10 +182,10 @@ main(int argc, char **argv) {
 			break;
 		case 'K':
 			directory = isc_commandline_argument;
-			ret = try_dir(directory);
-			if (ret != ISC_R_SUCCESS) {
+			result = try_dir(directory);
+			if (result != ISC_R_SUCCESS) {
 				fatal("cannot open directory %s: %s", directory,
-				      isc_result_totext(ret));
+				      isc_result_totext(result));
 			}
 			break;
 		case 'k':
@@ -358,11 +358,11 @@ main(int argc, char **argv) {
 		isc_buffer_init(&buf, argv[isc_commandline_index],
 				strlen(argv[isc_commandline_index]));
 		isc_buffer_add(&buf, strlen(argv[isc_commandline_index]));
-		ret = dns_name_fromtext(name, &buf, dns_rootname, 0);
-		if (ret != ISC_R_SUCCESS) {
+		result = dns_name_fromtext(name, &buf, dns_rootname, 0);
+		if (result != ISC_R_SUCCESS) {
 			fatal("invalid key name %s: %s",
 			      argv[isc_commandline_index],
-			      isc_result_totext(ret));
+			      isc_result_totext(result));
 		}
 
 		if (strchr(label, ':') == NULL) {
@@ -382,8 +382,8 @@ main(int argc, char **argv) {
 
 		r.base = algname;
 		r.length = strlen(algname);
-		ret = dst_algorithm_fromtext(&alg, &r);
-		if (ret != ISC_R_SUCCESS) {
+		result = dst_algorithm_fromtext(&alg, &r);
+		if (result != ISC_R_SUCCESS) {
 			fatal("unknown algorithm %s", algname);
 		}
 
@@ -459,12 +459,13 @@ main(int argc, char **argv) {
 			fatal("-S and -G cannot be used together");
 		}
 
-		ret = dst_key_fromnamedfile(predecessor, directory,
-					    DST_TYPE_PUBLIC | DST_TYPE_PRIVATE,
-					    isc_g_mctx, &prevkey);
-		if (ret != ISC_R_SUCCESS) {
+		result = dst_key_fromnamedfile(predecessor, directory,
+					       DST_TYPE_PUBLIC |
+						       DST_TYPE_PRIVATE,
+					       isc_g_mctx, &prevkey);
+		if (result != ISC_R_SUCCESS) {
 			fatal("Invalid keyfile %s: %s", predecessor,
-			      isc_result_totext(ret));
+			      isc_result_totext(result));
 		}
 		if (!dst_key_isprivate(prevkey)) {
 			fatal("%s is not a private key", predecessor);
@@ -482,16 +483,16 @@ main(int argc, char **argv) {
 			      keystr, major, minor);
 		}
 
-		ret = dst_key_gettime(prevkey, DST_TIME_ACTIVATE, &when);
-		if (ret != ISC_R_SUCCESS) {
+		result = dst_key_gettime(prevkey, DST_TIME_ACTIVATE, &when);
+		if (result != ISC_R_SUCCESS) {
 			fatal("Key %s has no activation date.\n\t"
 			      "You must use dnssec-settime -A to set one "
 			      "before generating a successor.",
 			      keystr);
 		}
 
-		ret = dst_key_gettime(prevkey, DST_TIME_INACTIVE, &activate);
-		if (ret != ISC_R_SUCCESS) {
+		result = dst_key_gettime(prevkey, DST_TIME_INACTIVE, &activate);
+		if (result != ISC_R_SUCCESS) {
 			fatal("Key %s has no inactivation date.\n\t"
 			      "You must use dnssec-settime -I to set one "
 			      "before generating a successor.",
@@ -510,8 +511,8 @@ main(int argc, char **argv) {
 			      keystr);
 		}
 
-		ret = dst_key_gettime(prevkey, DST_TIME_DELETE, &when);
-		if (ret != ISC_R_SUCCESS) {
+		result = dst_key_gettime(prevkey, DST_TIME_DELETE, &when);
+		if (result != ISC_R_SUCCESS) {
 			fprintf(stderr,
 				"%s: WARNING: Key %s has no removal "
 				"date;\n\t it will remain in the zone "
@@ -556,16 +557,16 @@ main(int argc, char **argv) {
 	isc_buffer_init(&buf, filename, sizeof(filename) - 1);
 
 	/* associate the key */
-	ret = dst_key_fromlabel(name, alg, flags, DNS_KEYPROTO_DNSSEC, rdclass,
-				label, NULL, isc_g_mctx, &key);
+	result = dst_key_fromlabel(name, alg, flags, DNS_KEYPROTO_DNSSEC,
+				   rdclass, label, NULL, isc_g_mctx, &key);
 
-	if (ret != ISC_R_SUCCESS) {
+	if (result != ISC_R_SUCCESS) {
 		char namestr[DNS_NAME_FORMATSIZE];
 		char algstr[DNS_SECALG_FORMATSIZE];
 		dns_name_format(name, namestr, sizeof(namestr));
 		dns_secalg_format(alg, algstr, sizeof(algstr));
 		fatal("failed to get key %s/%s: %s", namestr, algstr,
-		      isc_result_totext(ret));
+		      isc_result_totext(result));
 		UNREACHABLE();
 		exit(EXIT_FAILURE);
 	}
@@ -651,10 +652,10 @@ main(int argc, char **argv) {
 			  &exact))
 	{
 		isc_buffer_clear(&buf);
-		ret = dst_key_buildfilename(key, 0, directory, &buf);
-		if (ret != ISC_R_SUCCESS) {
+		result = dst_key_buildfilename(key, 0, directory, &buf);
+		if (result != ISC_R_SUCCESS) {
 			fatal("dst_key_buildfilename returned: %s\n",
-			      isc_result_totext(ret));
+			      isc_result_totext(result));
 		}
 		if (exact) {
 			fatal("%s: %s already exists\n",
@@ -675,19 +676,19 @@ main(int argc, char **argv) {
 			isc_commandline_progname, filename);
 	}
 
-	ret = dst_key_tofile(key, options, directory);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_key_tofile(key, options, directory);
+	if (result != ISC_R_SUCCESS) {
 		char keystr[DST_KEY_FORMATSIZE];
 		dst_key_format(key, keystr, sizeof(keystr));
 		fatal("failed to write key %s: %s\n", keystr,
-		      isc_result_totext(ret));
+		      isc_result_totext(result));
 	}
 
 	isc_buffer_clear(&buf);
-	ret = dst_key_buildfilename(key, 0, NULL, &buf);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_key_buildfilename(key, 0, NULL, &buf);
+	if (result != ISC_R_SUCCESS) {
 		fatal("dst_key_buildfilename returned: %s\n",
-		      isc_result_totext(ret));
+		      isc_result_totext(result));
 	}
 	printf("%s\n", filename);
 	dst_key_free(&key);
diff --git a/bin/dnssec/dnssec-keygen.c b/bin/dnssec/dnssec-keygen.c
index 6c6e82f097d..17556b17b9c 100644
--- a/bin/dnssec/dnssec-keygen.c
+++ b/bin/dnssec/dnssec-keygen.c
@@ -241,7 +241,7 @@ keygen(keygen_ctx_t *ctx, int argc, char **argv) {
 	isc_buffer_t buf;
 	dns_name_t *name;
 	dns_fixedname_t fname;
-	isc_result_t ret;
+	isc_result_t result;
 	dst_key_t *key = NULL;
 	dst_key_t *prevkey = NULL;
 
@@ -258,11 +258,11 @@ keygen(keygen_ctx_t *ctx, int argc, char **argv) {
 		isc_buffer_init(&buf, argv[isc_commandline_index],
 				strlen(argv[isc_commandline_index]));
 		isc_buffer_add(&buf, strlen(argv[isc_commandline_index]));
-		ret = dns_name_fromtext(name, &buf, dns_rootname, 0);
-		if (ret != ISC_R_SUCCESS) {
+		result = dns_name_fromtext(name, &buf, dns_rootname, 0);
+		if (result != ISC_R_SUCCESS) {
 			fatal("invalid key name %s: %s",
 			      argv[isc_commandline_index],
-			      isc_result_totext(ret));
+			      isc_result_totext(result));
 		}
 
 		if (!dst_algorithm_supported(ctx->alg)) {
@@ -391,13 +391,13 @@ keygen(keygen_ctx_t *ctx, int argc, char **argv) {
 			fatal("-S and -G cannot be used together");
 		}
 
-		ret = dst_key_fromnamedfile(ctx->predecessor, ctx->directory,
-					    DST_TYPE_PUBLIC | DST_TYPE_PRIVATE |
-						    DST_TYPE_STATE,
-					    isc_g_mctx, &prevkey);
-		if (ret != ISC_R_SUCCESS) {
+		result = dst_key_fromnamedfile(
+			ctx->predecessor, ctx->directory,
+			DST_TYPE_PUBLIC | DST_TYPE_PRIVATE | DST_TYPE_STATE,
+			isc_g_mctx, &prevkey);
+		if (result != ISC_R_SUCCESS) {
 			fatal("Invalid keyfile %s: %s", ctx->predecessor,
-			      isc_result_totext(ret));
+			      isc_result_totext(result));
 		}
 		if (!dst_key_isprivate(prevkey)) {
 			fatal("%s is not a private key", ctx->predecessor);
@@ -416,17 +416,17 @@ keygen(keygen_ctx_t *ctx, int argc, char **argv) {
 			      keystr, major, minor);
 		}
 
-		ret = dst_key_gettime(prevkey, DST_TIME_ACTIVATE, &when);
-		if (ret != ISC_R_SUCCESS) {
+		result = dst_key_gettime(prevkey, DST_TIME_ACTIVATE, &when);
+		if (result != ISC_R_SUCCESS) {
 			fatal("Key %s has no activation date.\n\t"
 			      "You must use dnssec-settime -A to set one "
 			      "before generating a successor.",
 			      keystr);
 		}
 
-		ret = dst_key_gettime(prevkey, DST_TIME_INACTIVE,
-				      &ctx->activate);
-		if (ret != ISC_R_SUCCESS) {
+		result = dst_key_gettime(prevkey, DST_TIME_INACTIVE,
+					 &ctx->activate);
+		if (result != ISC_R_SUCCESS) {
 			fatal("Key %s has no inactivation date.\n\t"
 			      "You must use dnssec-settime -I to set one "
 			      "before generating a successor.",
@@ -445,8 +445,8 @@ keygen(keygen_ctx_t *ctx, int argc, char **argv) {
 			      keystr);
 		}
 
-		ret = dst_key_gettime(prevkey, DST_TIME_DELETE, &when);
-		if (ret != ISC_R_SUCCESS) {
+		result = dst_key_gettime(prevkey, DST_TIME_DELETE, &when);
+		if (result != ISC_R_SUCCESS) {
 			fprintf(stderr,
 				"%s: WARNING: Key %s has no removal "
 				"date;\n\t it will remain in the zone "
@@ -558,19 +558,19 @@ keygen(keygen_ctx_t *ctx, int argc, char **argv) {
 		}
 
 		if (ctx->keystore != NULL && ctx->policy != NULL) {
-			ret = dns_keystore_keygen(
+			result = dns_keystore_keygen(
 				ctx->keystore, name, ctx->policy, ctx->rdclass,
 				isc_g_mctx, ctx->alg, ctx->size, flags, &key);
 		} else if (!ctx->quiet && show_progress) {
-			ret = dst_key_generate(name, ctx->alg, ctx->size, 0,
-					       flags, DNS_KEYPROTO_DNSSEC,
-					       ctx->rdclass, NULL, isc_g_mctx,
-					       &key, &progress);
+			result = dst_key_generate(name, ctx->alg, ctx->size, 0,
+						  flags, DNS_KEYPROTO_DNSSEC,
+						  ctx->rdclass, NULL,
+						  isc_g_mctx, &key, &progress);
 		} else {
-			ret = dst_key_generate(name, ctx->alg, ctx->size, 0,
-					       flags, DNS_KEYPROTO_DNSSEC,
-					       ctx->rdclass, NULL, isc_g_mctx,
-					       &key, NULL);
+			result = dst_key_generate(name, ctx->alg, ctx->size, 0,
+						  flags, DNS_KEYPROTO_DNSSEC,
+						  ctx->rdclass, NULL,
+						  isc_g_mctx, &key, NULL);
 		}
 
 		if (!ctx->quiet && show_progress) {
@@ -578,11 +578,11 @@ keygen(keygen_ctx_t *ctx, int argc, char **argv) {
 			fflush(stderr);
 		}
 
-		if (ret != ISC_R_SUCCESS) {
+		if (result != ISC_R_SUCCESS) {
 			char namestr[DNS_NAME_FORMATSIZE];
 			dns_name_format(name, namestr, sizeof(namestr));
 			fatal("failed to generate key %s/%s: %s\n", namestr,
-			      algstr, isc_result_totext(ret));
+			      algstr, isc_result_totext(result));
 		}
 
 		/*
@@ -715,9 +715,9 @@ keygen(keygen_ctx_t *ctx, int argc, char **argv) {
 
 			if (verbose > 0) {
 				isc_buffer_clear(&buf);
-				ret = dst_key_buildfilename(
+				result = dst_key_buildfilename(
 					key, 0, ctx->directory, &buf);
-				if (ret == ISC_R_SUCCESS) {
+				if (result == ISC_R_SUCCESS) {
 					fprintf(stderr,
 						"%s: %s already exists, or "
 						"might collide with another "
@@ -741,28 +741,28 @@ keygen(keygen_ctx_t *ctx, int argc, char **argv) {
 		dst_key_setnum(prevkey, DST_NUM_SUCCESSOR, dst_key_id(key));
 		dst_key_setnum(key, DST_NUM_PREDECESSOR, dst_key_id(prevkey));
 
-		ret = dst_key_tofile(prevkey, ctx->options, ctx->directory);
-		if (ret != ISC_R_SUCCESS) {
+		result = dst_key_tofile(prevkey, ctx->options, ctx->directory);
+		if (result != ISC_R_SUCCESS) {
 			char keystr[DST_KEY_FORMATSIZE];
 			dst_key_format(prevkey, keystr, sizeof(keystr));
 			fatal("failed to update predecessor %s: %s\n", keystr,
-			      isc_result_totext(ret));
+			      isc_result_totext(result));
 		}
 	}
 
-	ret = dst_key_tofile(key, ctx->options, ctx->directory);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_key_tofile(key, ctx->options, ctx->directory);
+	if (result != ISC_R_SUCCESS) {
 		char keystr[DST_KEY_FORMATSIZE];
 		dst_key_format(key, keystr, sizeof(keystr));
 		fatal("failed to write key %s: %s\n", keystr,
-		      isc_result_totext(ret));
+		      isc_result_totext(result));
 	}
 
 	isc_buffer_clear(&buf);
-	ret = dst_key_buildfilename(key, 0, NULL, &buf);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_key_buildfilename(key, 0, NULL, &buf);
+	if (result != ISC_R_SUCCESS) {
 		fatal("dst_key_buildfilename returned: %s\n",
-		      isc_result_totext(ret));
+		      isc_result_totext(result));
 	}
 	printf("%s\n", filename);
 
@@ -776,10 +776,10 @@ static void
 check_keystore_options(keygen_ctx_t *ctx) {
 	ctx->directory = dns_keystore_directory(ctx->keystore, NULL);
 	if (ctx->directory != NULL) {
-		isc_result_t ret = try_dir(ctx->directory);
-		if (ret != ISC_R_SUCCESS) {
+		isc_result_t result = try_dir(ctx->directory);
+		if (result != ISC_R_SUCCESS) {
 			fatal("cannot open directory %s: %s", ctx->directory,
-			      isc_result_totext(ret));
+			      isc_result_totext(result));
 		}
 	}
 }
@@ -789,7 +789,7 @@ main(int argc, char **argv) {
 	char *algname = NULL, *freeit = NULL;
 	char *classname = NULL;
 	char *endp;
-	isc_result_t ret;
+	isc_result_t result;
 	isc_textregion_t r;
 	unsigned char c;
 	int ch;
@@ -878,10 +878,10 @@ main(int argc, char **argv) {
 			break;
 		case 'K':
 			ctx.directory = isc_commandline_argument;
-			ret = try_dir(ctx.directory);
-			if (ret != ISC_R_SUCCESS) {
+			result = try_dir(ctx.directory);
+			if (result != ISC_R_SUCCESS) {
 				fatal("cannot open directory %s: %s",
-				      ctx.directory, isc_result_totext(ret));
+				      ctx.directory, isc_result_totext(result));
 			}
 			break;
 		case 'k':
@@ -1096,8 +1096,8 @@ main(int argc, char **argv) {
 		}
 		r.base = algname;
 		r.length = strlen(algname);
-		ret = dst_algorithm_fromtext(&ctx.alg, &r);
-		if (ret != ISC_R_SUCCESS) {
+		result = dst_algorithm_fromtext(&ctx.alg, &r);
+		if (result != ISC_R_SUCCESS) {
 			fatal("unknown algorithm %s", algname);
 		}
 		if (!dst_algorithm_supported(ctx.alg)) {
diff --git a/bin/dnssec/dnssec-signzone.c b/bin/dnssec/dnssec-signzone.c
index 4502d00720f..3b139ef91ce 100644
--- a/bin/dnssec/dnssec-signzone.c
+++ b/bin/dnssec/dnssec-signzone.c
@@ -727,9 +727,9 @@ signset(dns_diff_t *del, dns_diff_t *add, dns_dbnode_t *node, dns_name_t *name,
 			 */
 			bool have_pre_sig = false;
 			uint32_t pre;
-			isc_result_t ret = dst_key_getnum(
-				key->key, DST_NUM_PREDECESSOR, &pre);
-			if (ret == ISC_R_SUCCESS) {
+			result = dst_key_getnum(key->key, DST_NUM_PREDECESSOR,
+						&pre);
+			if (result == ISC_R_SUCCESS) {
 				/*
 				 * This key has a predecessor, look for the
 				 * corresponding key in the keylist. The
@@ -749,10 +749,10 @@ signset(dns_diff_t *del, dns_diff_t *add, dns_dbnode_t *node, dns_name_t *name,
 					{
 						continue;
 					}
-					ret = dst_key_getnum(curr->key,
-							     DST_NUM_SUCCESSOR,
-							     &suc);
-					if (ret != ISC_R_SUCCESS ||
+					result = dst_key_getnum(
+						curr->key, DST_NUM_SUCCESSOR,
+						&suc);
+					if (result != ISC_R_SUCCESS ||
 					    dst_key_id(key->key) != suc)
 					{
 						continue;
diff --git a/lib/dns/dnssec.c b/lib/dns/dnssec.c
index f079dcc472a..7711fb92b1c 100644
--- a/lib/dns/dnssec.c
+++ b/lib/dns/dnssec.c
@@ -85,7 +85,7 @@ rdata_compare_wrapper(const void *rdata1, const void *rdata2) {
 static isc_result_t
 rdataset_to_sortedarray(dns_rdataset_t *set, isc_mem_t *mctx,
 			dns_rdata_t **rdata, int *nrdata) {
-	isc_result_t ret;
+	isc_result_t result;
 	int i = 0, n;
 	dns_rdata_t *data;
 	dns_rdataset_t rdataset;
@@ -96,11 +96,11 @@ rdataset_to_sortedarray(dns_rdataset_t *set, isc_mem_t *mctx,
 
 	dns_rdataset_init(&rdataset);
 	dns_rdataset_clone(set, &rdataset);
-	ret = dns_rdataset_first(&rdataset);
-	if (ret != ISC_R_SUCCESS) {
+	result = dns_rdataset_first(&rdataset);
+	if (result != ISC_R_SUCCESS) {
 		dns_rdataset_disassociate(&rdataset);
 		isc_mem_cput(mctx, data, n, sizeof(dns_rdata_t));
-		return ret;
+		return result;
 	}
 
 	/*
@@ -177,7 +177,7 @@ dns_dnssec_sign(const dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
 	isc_buffer_t sigbuf, envbuf;
 	isc_region_t r;
 	dst_context_t *ctx = NULL;
-	isc_result_t ret;
+	isc_result_t result;
 	isc_buffer_t *databuf = NULL;
 	char data[256 + 8];
 	unsigned int sigsize;
@@ -232,22 +232,23 @@ dns_dnssec_sign(const dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
 	isc_buffer_allocate(mctx, &databuf, sigsize + 256 + 18);
 
 	dns_rdata_init(&tmpsigrdata);
-	ret = dns_rdata_fromstruct(&tmpsigrdata, sig.common.rdclass,
-				   sig.common.rdtype, &sig, databuf);
-	if (ret != ISC_R_SUCCESS) {
+	result = dns_rdata_fromstruct(&tmpsigrdata, sig.common.rdclass,
+				      sig.common.rdtype, &sig, databuf);
+	if (result != ISC_R_SUCCESS) {
 		goto cleanup_databuf;
 	}
 
-	ret = dst_context_create(key, mctx, DNS_LOGCATEGORY_DNSSEC, true, &ctx);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_context_create(key, mctx, DNS_LOGCATEGORY_DNSSEC, true,
+				    &ctx);
+	if (result != ISC_R_SUCCESS) {
 		goto cleanup_databuf;
 	}
 
 	/*
 	 * Digest the SIG rdata.
 	 */
-	ret = digest_sig(ctx, false, &tmpsigrdata, &sig);
-	if (ret != ISC_R_SUCCESS) {
+	result = digest_sig(ctx, false, &tmpsigrdata, &sig);
+	if (result != ISC_R_SUCCESS) {
 		goto cleanup_context;
 	}
 
@@ -266,8 +267,8 @@ dns_dnssec_sign(const dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
 	isc_buffer_putuint16(&envbuf, set->rdclass);
 	isc_buffer_putuint32(&envbuf, set->ttl);
 
-	ret = rdataset_to_sortedarray(set, mctx, &rdatas, &nrdatas);
-	if (ret != ISC_R_SUCCESS) {
+	result = rdataset_to_sortedarray(set, mctx, &rdatas, &nrdatas);
+	if (result != ISC_R_SUCCESS) {
 		goto cleanup_context;
 	}
 	isc_buffer_usedregion(&envbuf, &r);
@@ -288,8 +289,8 @@ dns_dnssec_sign(const dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
 		/*
 		 * Digest the envelope.
 		 */
-		ret = dst_context_adddata(ctx, &r);
-		if (ret != ISC_R_SUCCESS) {
+		result = dst_context_adddata(ctx, &r);
+		if (result != ISC_R_SUCCESS) {
 			goto cleanup_array;
 		}
 
@@ -299,33 +300,33 @@ dns_dnssec_sign(const dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
 		isc_buffer_init(&lenbuf, &len, sizeof(len));
 		isc_buffer_putuint16(&lenbuf, (uint16_t)rdatas[i].length);
 		isc_buffer_usedregion(&lenbuf, &lenr);
-		ret = dst_context_adddata(ctx, &lenr);
-		if (ret != ISC_R_SUCCESS) {
+		result = dst_context_adddata(ctx, &lenr);
+		if (result != ISC_R_SUCCESS) {
 			goto cleanup_array;
 		}
 
 		/*
 		 * Digest the rdata.
 		 */
-		ret = dns_rdata_digest(&rdatas[i], digest_callback, ctx);
-		if (ret != ISC_R_SUCCESS) {
+		result = dns_rdata_digest(&rdatas[i], digest_callback, ctx);
+		if (result != ISC_R_SUCCESS) {
 			goto cleanup_array;
 		}
 	}
 
 	isc_buffer_init(&sigbuf, sig.signature, sig.siglen);
-	ret = dst_context_sign(ctx, &sigbuf);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_context_sign(ctx, &sigbuf);
+	if (result != ISC_R_SUCCESS) {
 		goto cleanup_array;
 	}
 	isc_buffer_usedregion(&sigbuf, &r);
 	if (r.length != sig.siglen) {
-		ret = ISC_R_NOSPACE;
+		result = ISC_R_NOSPACE;
 		goto cleanup_array;
 	}
 
-	ret = dns_rdata_fromstruct(sigrdata, sig.common.rdclass,
-				   sig.common.rdtype, &sig, buffer);
+	result = dns_rdata_fromstruct(sigrdata, sig.common.rdclass,
+				      sig.common.rdtype, &sig, buffer);
 
 cleanup_array:
 	isc_mem_cput(mctx, rdatas, nrdatas, sizeof(dns_rdata_t));
@@ -335,7 +336,7 @@ cleanup_databuf:
 	isc_buffer_free(&databuf);
 	isc_mem_put(mctx, sig.signature, sig.siglen);
 
-	return ret;
+	return result;
 }
 
 isc_result_t
@@ -349,7 +350,7 @@ dns_dnssec_verify(const dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
 	dns_rdata_t *rdatas;
 	int nrdatas, i;
 	isc_stdtime_t now;
-	isc_result_t ret;
+	isc_result_t result;
 	unsigned char data[300];
 	dst_context_t *ctx = NULL;
 	int labels = 0;
@@ -415,17 +416,17 @@ dns_dnssec_verify(const dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
 	}
 
 again:
-	ret = dst_context_create(key, mctx, DNS_LOGCATEGORY_DNSSEC, false,
-				 &ctx);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_context_create(key, mctx, DNS_LOGCATEGORY_DNSSEC, false,
+				    &ctx);
+	if (result != ISC_R_SUCCESS) {
 		goto cleanup_struct;
 	}
 
 	/*
 	 * Digest the SIG rdata (not including the signature).
 	 */
-	ret = digest_sig(ctx, downcase, sigrdata, &sig);
-	if (ret != ISC_R_SUCCESS) {
+	result = digest_sig(ctx, downcase, sigrdata, &sig);
+	if (result != ISC_R_SUCCESS) {
 		goto cleanup_context;
 	}
 
@@ -459,8 +460,8 @@ again:
 	isc_buffer_putuint16(&envbuf, set->rdclass);
 	isc_buffer_putuint32(&envbuf, sig.originalttl);
 
-	ret = rdataset_to_sortedarray(set, mctx, &rdatas, &nrdatas);
-	if (ret != ISC_R_SUCCESS) {
+	result = rdataset_to_sortedarray(set, mctx, &rdatas, &nrdatas);
+	if (result != ISC_R_SUCCESS) {
 		goto cleanup_context;
 	}
 
@@ -482,8 +483,8 @@ again:
 		/*
 		 * Digest the envelope.
 		 */
-		ret = dst_context_adddata(ctx, &r);
-		if (ret != ISC_R_SUCCESS) {
+		result = dst_context_adddata(ctx, &r);
+		if (result != ISC_R_SUCCESS) {
 			goto cleanup_array;
 		}
 
@@ -497,20 +498,20 @@ again:
 		/*
 		 * Digest the rdata.
 		 */
-		ret = dst_context_adddata(ctx, &lenr);
-		if (ret != ISC_R_SUCCESS) {
+		result = dst_context_adddata(ctx, &lenr);
+		if (result != ISC_R_SUCCESS) {
 			goto cleanup_array;
 		}
-		ret = dns_rdata_digest(&rdatas[i], digest_callback, ctx);
-		if (ret != ISC_R_SUCCESS) {
+		result = dns_rdata_digest(&rdatas[i], digest_callback, ctx);
+		if (result != ISC_R_SUCCESS) {
 			goto cleanup_array;
 		}
 	}
 
 	r.base = sig.signature;
 	r.length = sig.siglen;
-	ret = dst_context_verify(ctx, &r);
-	if (ret == ISC_R_SUCCESS && downcase) {
+	result = dst_context_verify(ctx, &r);
+	if (result == ISC_R_SUCCESS && downcase) {
 		char namebuf[DNS_NAME_FORMATSIZE];
 		dns_name_format(&sig.signer, namebuf, sizeof(namebuf));
 		isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
@@ -519,7 +520,7 @@ again:
 			      "signer '%s'",
 			      namebuf);
 		inc_stat(dns_dnssecstats_downcase);
-	} else if (ret == ISC_R_SUCCESS) {
+	} else if (result == ISC_R_SUCCESS) {
 		inc_stat(dns_dnssecstats_asis);
 	}
 
@@ -527,22 +528,22 @@ cleanup_array:
 	isc_mem_cput(mctx, rdatas, nrdatas, sizeof(dns_rdata_t));
 cleanup_context:
 	dst_context_destroy(&ctx);
-	if (ret == DST_R_VERIFYFAILURE && !downcase) {
+	if (result == DST_R_VERIFYFAILURE && !downcase) {
 		downcase = true;
 		goto again;
 	}
 cleanup_struct:
 	dns_rdata_freestruct(&sig);
 
-	if (ret == DST_R_VERIFYFAILURE) {
-		ret = DNS_R_SIGINVALID;
+	if (result == DST_R_VERIFYFAILURE) {
+		result = DNS_R_SIGINVALID;
 	}
 
-	if (ret != ISC_R_SUCCESS) {
+	if (result != ISC_R_SUCCESS) {
 		inc_stat(dns_dnssecstats_fail);
 	}
 
-	if (ret == ISC_R_SUCCESS && labels - sig.labels > 0) {
+	if (result == ISC_R_SUCCESS && labels - sig.labels > 0) {
 		if (wild != NULL) {
 			RUNTIME_CHECK(dns_name_concatenate(
 					      dns_wildcardname,
@@ -550,9 +551,9 @@ cleanup_struct:
 					      wild) == ISC_R_SUCCESS);
 		}
 		inc_stat(dns_dnssecstats_wildcard);
-		ret = DNS_R_FROMWILDCARD;
+		result = DNS_R_FROMWILDCARD;
 	}
-	return ret;
+	return result;
 }
 
 bool
@@ -562,19 +563,18 @@ dns_dnssec_keyactive(dst_key_t *key, isc_stdtime_t now) {
 	bool hint_publish, hint_zsign, hint_ksign, hint_revoke, hint_remove;
 	int major, minor;
 	bool ksk = false, zsk = false;
-	isc_result_t ret;
 
 	/* Is this an old-style key? */
 	result = dst_key_getprivateformat(key, &major, &minor);
 	RUNTIME_CHECK(result == ISC_R_SUCCESS);
 
 	/* Is this a KSK? */
-	ret = dst_key_getbool(key, DST_BOOL_KSK, &ksk);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_key_getbool(key, DST_BOOL_KSK, &ksk);
+	if (result != ISC_R_SUCCESS) {
 		ksk = ((dst_key_flags(key) & DNS_KEYFLAG_KSK) != 0);
 	}
-	ret = dst_key_getbool(key, DST_BOOL_ZSK, &zsk);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_key_getbool(key, DST_BOOL_ZSK, &zsk);
+	if (result != ISC_R_SUCCESS) {
 		zsk = ((dst_key_flags(key) & DNS_KEYFLAG_KSK) == 0);
 	}
 
diff --git a/lib/dns/hmac_link.c b/lib/dns/hmac_link.c
index 1a9a1631911..320b8adb855 100644
--- a/lib/dns/hmac_link.c
+++ b/lib/dns/hmac_link.c
@@ -272,7 +272,7 @@ hmac_compare(const isc_md_type_t *type, const dst_key_t *key1,
 static isc_result_t
 hmac_generate(const isc_md_type_t *type, dst_key_t *key) {
 	isc_buffer_t b;
-	isc_result_t ret;
+	isc_result_t result;
 	unsigned int bytes, len;
 	unsigned char data[ISC_MAX_MD_SIZE] = { 0 };
 
@@ -290,11 +290,11 @@ hmac_generate(const isc_md_type_t *type, dst_key_t *key) {
 	isc_buffer_init(&b, data, bytes);
 	isc_buffer_add(&b, bytes);
 
-	ret = hmac_fromdns(type, key, &b);
+	result = hmac_fromdns(type, key, &b);
 
 	isc_safe_memwipe(data, sizeof(data));
 
-	return ret;
+	return result;
 }
 
 static bool
diff --git a/lib/dns/kasp.c b/lib/dns/kasp.c
index 76a59c225d0..f3ea00eb967 100644
--- a/lib/dns/kasp.c
+++ b/lib/dns/kasp.c
@@ -522,7 +522,7 @@ dns_kasp_key_tagmax(dns_kasp_key_t *key) {
 
 bool
 dns_kasp_key_match(dns_kasp_key_t *key, dns_dnsseckey_t *dkey) {
-	isc_result_t ret;
+	isc_result_t result;
 	bool role = false;
 
 	REQUIRE(key != NULL);
@@ -537,12 +537,12 @@ dns_kasp_key_match(dns_kasp_key_t *key, dns_dnsseckey_t *dkey) {
 		return false;
 	}
 	/* Matching role? */
-	ret = dst_key_getbool(dkey->key, DST_BOOL_KSK, &role);
-	if (ret != ISC_R_SUCCESS || role != dns_kasp_key_ksk(key)) {
+	result = dst_key_getbool(dkey->key, DST_BOOL_KSK, &role);
+	if (result != ISC_R_SUCCESS || role != dns_kasp_key_ksk(key)) {
 		return false;
 	}
-	ret = dst_key_getbool(dkey->key, DST_BOOL_ZSK, &role);
-	if (ret != ISC_R_SUCCESS || role != dns_kasp_key_zsk(key)) {
+	result = dst_key_getbool(dkey->key, DST_BOOL_ZSK, &role);
+	if (result != ISC_R_SUCCESS || role != dns_kasp_key_zsk(key)) {
 		return false;
 	}
 	/* Valid key tag range? */
diff --git a/lib/dns/keymgr.c b/lib/dns/keymgr.c
index acb31bd322a..f38936aef80 100644
--- a/lib/dns/keymgr.c
+++ b/lib/dns/keymgr.c
@@ -96,13 +96,13 @@ log_key_overflow(dst_key_t *key, const char *what) {
 static const char *
 keymgr_keyrole(dst_key_t *key) {
 	bool ksk = false, zsk = false;
-	isc_result_t ret;
-	ret = dst_key_getbool(key, DST_BOOL_KSK, &ksk);
-	if (ret != ISC_R_SUCCESS) {
+	isc_result_t result;
+	result = dst_key_getbool(key, DST_BOOL_KSK, &ksk);
+	if (result != ISC_R_SUCCESS) {
 		return "UNKNOWN";
 	}
-	ret = dst_key_getbool(key, DST_BOOL_ZSK, &zsk);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_key_getbool(key, DST_BOOL_ZSK, &zsk);
+	if (result != ISC_R_SUCCESS) {
 		return "UNKNOWN";
 	}
 	if (ksk && zsk) {
@@ -123,26 +123,26 @@ static void
 keymgr_settime_remove(dns_dnsseckey_t *key, dns_kasp_t *kasp) {
 	isc_stdtime_t retire = 0, remove = 0, ksk_remove = 0, zsk_remove = 0;
 	bool zsk = false, ksk = false;
-	isc_result_t ret;
+	isc_result_t result;
 
 	REQUIRE(key != NULL);
 	REQUIRE(key->key != NULL);
 
-	ret = dst_key_gettime(key->key, DST_TIME_INACTIVE, &retire);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_key_gettime(key->key, DST_TIME_INACTIVE, &retire);
+	if (result != ISC_R_SUCCESS) {
 		return;
 	}
 
-	ret = dst_key_getbool(key->key, DST_BOOL_ZSK, &zsk);
-	if (ret == ISC_R_SUCCESS && zsk) {
+	result = dst_key_getbool(key->key, DST_BOOL_ZSK, &zsk);
+	if (result == ISC_R_SUCCESS && zsk) {
 		dns_ttl_t ttlsig = dns_kasp_zonemaxttl(kasp, true);
 		/* ZSK: Iret = Dsgn + Dprp + TTLsig */
 		zsk_remove =
 			retire + ttlsig + dns_kasp_zonepropagationdelay(kasp) +
 			dns_kasp_retiresafety(kasp) + dns_kasp_signdelay(kasp);
 	}
-	ret = dst_key_getbool(key->key, DST_BOOL_KSK, &ksk);
-	if (ret == ISC_R_SUCCESS && ksk) {
+	result = dst_key_getbool(key->key, DST_BOOL_KSK, &ksk);
+	if (result == ISC_R_SUCCESS && ksk) {
 		/* KSK: Iret = DprpP + TTLds */
 		ksk_remove = retire + dns_kasp_dsttl(kasp) +
 			     dns_kasp_parentpropagationdelay(kasp) +
@@ -161,17 +161,17 @@ void
 dns_keymgr_settime_syncpublish(dst_key_t *key, dns_kasp_t *kasp, bool first) {
 	isc_stdtime_t published, syncpublish;
 	bool ksk = false;
-	isc_result_t ret;
+	isc_result_t result;
 
 	REQUIRE(key != NULL);
 
-	ret = dst_key_gettime(key, DST_TIME_PUBLISH, &published);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_key_gettime(key, DST_TIME_PUBLISH, &published);
+	if (result != ISC_R_SUCCESS) {
 		return;
 	}
 
-	ret = dst_key_getbool(key, DST_BOOL_KSK, &ksk);
-	if (ret != ISC_R_SUCCESS || !ksk) {
+	result = dst_key_getbool(key, DST_BOOL_KSK, &ksk);
+	if (result != ISC_R_SUCCESS || !ksk) {
 		return;
 	}
 
@@ -191,8 +191,8 @@ dns_keymgr_settime_syncpublish(dst_key_t *key, dns_kasp_t *kasp, bool first) {
 	dst_key_settime(key, DST_TIME_SYNCPUBLISH, syncpublish);
 
 	uint32_t lifetime = 0;
-	ret = dst_key_getnum(key, DST_NUM_LIFETIME, &lifetime);
-	if (ret == ISC_R_SUCCESS && lifetime > 0) {
+	result = dst_key_getnum(key, DST_NUM_LIFETIME, &lifetime);
+	if (result == ISC_R_SUCCESS && lifetime > 0) {
 		dst_key_settime(key, DST_TIME_SYNCDELETE,
 				syncpublish + lifetime);
 	}
@@ -215,7 +215,7 @@ dns_keymgr_settime_syncpublish(dst_key_t *key, dns_kasp_t *kasp, bool first) {
 static isc_stdtime_t
 keymgr_prepublication_time(dns_dnsseckey_t *key, dns_kasp_t *kasp,
 			   uint32_t lifetime, isc_stdtime_t now) {
-	isc_result_t ret;
+	isc_result_t result;
 	isc_stdtime_t active, retire, pub, prepub;
 	bool zsk = false, ksk = false;
 
@@ -230,14 +230,14 @@ keymgr_prepublication_time(dns_dnsseckey_t *key, dns_kasp_t *kasp,
 	 * An active key must have publish and activate timing
 	 * metadata.
 	 */
-	ret = dst_key_gettime(key->key, DST_TIME_ACTIVATE, &active);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_key_gettime(key->key, DST_TIME_ACTIVATE, &active);
+	if (result != ISC_R_SUCCESS) {
 		/* Super weird, but if it happens, set it to now. */
 		dst_key_settime(key->key, DST_TIME_ACTIVATE, now);
 		active = now;
 	}
-	ret = dst_key_gettime(key->key, DST_TIME_PUBLISH, &pub);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_key_gettime(key->key, DST_TIME_PUBLISH, &pub);
+	if (result != ISC_R_SUCCESS) {
 		/* Super weird, but if it happens, set it to now. */
 		dst_key_settime(key->key, DST_TIME_PUBLISH, now);
 		pub = now;
@@ -248,8 +248,8 @@ keymgr_prepublication_time(dns_dnsseckey_t *key, dns_kasp_t *kasp,
 	 * the key lifetime is required.
 	 */
 	uint32_t klifetime = 0;
-	ret = dst_key_getnum(key->key, DST_NUM_LIFETIME, &klifetime);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_key_getnum(key->key, DST_NUM_LIFETIME, &klifetime);
+	if (result != ISC_R_SUCCESS) {
 		dst_key_setnum(key->key, DST_NUM_LIFETIME, lifetime);
 		klifetime = lifetime;
 	}
@@ -259,23 +259,24 @@ keymgr_prepublication_time(dns_dnsseckey_t *key, dns_kasp_t *kasp,
 	 */
 	prepub = dst_key_getttl(key->key) + dns_kasp_publishsafety(kasp) +
 		 dns_kasp_zonepropagationdelay(kasp);
-	ret = dst_key_getbool(key->key, DST_BOOL_KSK, &ksk);
-	if (ret == ISC_R_SUCCESS && ksk) {
+	result = dst_key_getbool(key->key, DST_BOOL_KSK, &ksk);
+	if (result == ISC_R_SUCCESS && ksk) {
 		isc_stdtime_t syncpub;
 
 		/*
 		 * Set PublishCDS if not set.
 		 */
-		ret = dst_key_gettime(key->key, DST_TIME_SYNCPUBLISH, &syncpub);
-		if (ret != ISC_R_SUCCESS) {
+		result = dst_key_gettime(key->key, DST_TIME_SYNCPUBLISH,
+					 &syncpub);
+		if (result != ISC_R_SUCCESS) {
 			uint32_t tag;
 			isc_stdtime_t syncpub1, syncpub2;
 
 			syncpub1 = pub + prepub;
 			syncpub2 = 0;
-			ret = dst_key_getnum(key->key, DST_NUM_PREDECESSOR,
-					     &tag);
-			if (ret != ISC_R_SUCCESS) {
+			result = dst_key_getnum(key->key, DST_NUM_PREDECESSOR,
+						&tag);
+			if (result != ISC_R_SUCCESS) {
 				/*
 				 * No predecessor, wait for zone to be
 				 * completely signed.
@@ -303,8 +304,8 @@ keymgr_prepublication_time(dns_dnsseckey_t *key, dns_kasp_t *kasp,
 	 */
 	(void)dst_key_getbool(key->key, DST_BOOL_ZSK, &zsk);
 
-	ret = dst_key_gettime(key->key, DST_TIME_INACTIVE, &retire);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_key_gettime(key->key, DST_TIME_INACTIVE, &retire);
+	if (result != ISC_R_SUCCESS) {
 		if (klifetime == 0) {
 			/*
 			 * No inactive time and no lifetime,
@@ -339,7 +340,7 @@ static void
 keymgr_key_retire(dns_dnsseckey_t *key, dns_kasp_t *kasp, uint8_t opts,
 		  isc_stdtime_t now) {
 	char keystr[DST_KEY_FORMATSIZE];
-	isc_result_t ret;
+	isc_result_t result;
 	isc_stdtime_t retire;
 	dst_key_state_t s;
 	bool ksk = false, zsk = false;
@@ -349,8 +350,8 @@ keymgr_key_retire(dns_dnsseckey_t *key, dns_kasp_t *kasp, uint8_t opts,
 
 	dst_key_format(key->key, keystr, sizeof(keystr));
 
-	ret = dst_key_getstate(key->key, DST_KEY_GOAL, &s);
-	INSIST(ret == ISC_R_SUCCESS);
+	result = dst_key_getstate(key->key, DST_KEY_GOAL, &s);
+	INSIST(result == ISC_R_SUCCESS);
 
 	if (dns_kasp_manualmode(kasp) &&
 	    (opts & DNS_KEYMGRATTR_FORCESTEP) == 0 && s != HIDDEN)
@@ -374,8 +375,8 @@ keymgr_key_retire(dns_dnsseckey_t *key, dns_kasp_t *kasp, uint8_t opts,
 	 * This key may not have key states set yet. Pretend as if they are
 	 * in the OMNIPRESENT state.
 	 */
-	ret = dst_key_gettime(key->key, DST_TIME_INACTIVE, &retire);
-	if (ret != ISC_R_SUCCESS || (retire > now)) {
+	result = dst_key_gettime(key->key, DST_TIME_INACTIVE, &retire);
+	if (result != ISC_R_SUCCESS || (retire > now)) {
 		dst_key_settime(key->key, DST_TIME_INACTIVE, now);
 	}
 	keymgr_settime_remove(key, kasp);
@@ -385,8 +386,8 @@ keymgr_key_retire(dns_dnsseckey_t *key, dns_kasp_t *kasp, uint8_t opts,
 		dst_key_settime(key->key, DST_TIME_DNSKEY, now);
 	}
 
-	ret = dst_key_getbool(key->key, DST_BOOL_KSK, &ksk);
-	if (ret == ISC_R_SUCCESS && ksk) {
+	result = dst_key_getbool(key->key, DST_BOOL_KSK, &ksk);
+	if (result == ISC_R_SUCCESS && ksk) {
 		if (dst_key_getstate(key->key, DST_KEY_KRRSIG, &s) !=
 		    ISC_R_SUCCESS)
 		{
@@ -399,8 +400,8 @@ keymgr_key_retire(dns_dnsseckey_t *key, dns_kasp_t *kasp, uint8_t opts,
 			dst_key_settime(key->key, DST_TIME_DS, now);
 		}
 	}
-	ret = dst_key_getbool(key->key, DST_BOOL_ZSK, &zsk);
-	if (ret == ISC_R_SUCCESS && zsk) {
+	result = dst_key_getbool(key->key, DST_BOOL_ZSK, &zsk);
+	if (result == ISC_R_SUCCESS && zsk) {
 		if (dst_key_getstate(key->key, DST_KEY_ZRRSIG, &s) !=
 		    ISC_R_SUCCESS)
 		{
@@ -1309,7 +1310,7 @@ static void
 keymgr_transition_time(dns_dnsseckey_t *key, int type,
 		       dst_key_state_t next_state, dns_kasp_t *kasp,
 		       isc_stdtime_t now, isc_stdtime_t *when) {
-	isc_result_t ret;
+	isc_result_t result;
 	isc_stdtime_t lastchange, dstime, sigtime, nexttime = now;
 	dns_ttl_t ttlsig = dns_kasp_zonemaxttl(kasp, true);
 	uint32_t dsstate, sigstate, signdelay = 0;
@@ -1322,8 +1323,8 @@ keymgr_transition_time(dns_dnsseckey_t *key, int type,
 		return;
 	}
 
-	ret = dst_key_gettime(key->key, keystatetimes[type], &lastchange);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_key_gettime(key->key, keystatetimes[type], &lastchange);
+	if (result != ISC_R_SUCCESS) {
 		/* No last change, for safety purposes let's set it to now. */
 		dst_key_settime(key->key, keystatetimes[type], now);
 		lastchange = now;
@@ -1369,8 +1370,8 @@ keymgr_transition_time(dns_dnsseckey_t *key, int type,
 			/* Was there a full sign? */
 			sigstate = (next_state == HIDDEN) ? DST_TIME_SIGDELETE
 							  : DST_TIME_SIGPUBLISH;
-			ret = dst_key_gettime(key->key, sigstate, &sigtime);
-			if (ret == ISC_R_SUCCESS && sigtime <= now) {
+			result = dst_key_gettime(key->key, sigstate, &sigtime);
+			if (result == ISC_R_SUCCESS && sigtime <= now) {
 				signdelay = 0;
 			} else {
 				sigtime = lastchange;
@@ -1401,13 +1402,13 @@ keymgr_transition_time(dns_dnsseckey_t *key, int type,
 			 * there is an actual predecessor or successor key.
 			 */
 			uint32_t tag;
-			ret = dst_key_getnum(key->key, DST_NUM_PREDECESSOR,
-					     &tag);
-			if (ret != ISC_R_SUCCESS) {
-				ret = dst_key_getnum(key->key,
-						     DST_NUM_SUCCESSOR, &tag);
+			result = dst_key_getnum(key->key, DST_NUM_PREDECESSOR,
+						&tag);
+			if (result != ISC_R_SUCCESS) {
+				result = dst_key_getnum(
+					key->key, DST_NUM_SUCCESSOR, &tag);
 			}
-			if (ret == ISC_R_SUCCESS) {
+			if (result == ISC_R_SUCCESS) {
 				nexttime += signdelay +
 					    dns_kasp_retiresafety(kasp);
 			}
@@ -1442,8 +1443,8 @@ keymgr_transition_time(dns_dnsseckey_t *key, int type,
 			 * parent. */
 			dsstate = next_state == HIDDEN ? DST_TIME_DSDELETE
 						       : DST_TIME_DSPUBLISH;
-			ret = dst_key_gettime(key->key, dsstate, &dstime);
-			if (ret != ISC_R_SUCCESS || dstime > now) {
+			result = dst_key_gettime(key->key, dsstate, &dstime);
+			if (result != ISC_R_SUCCESS || dstime > now) {
 				/* Not yet, try again in an hour. */
 				nexttime = now + 3600;
 			} else {
@@ -1455,14 +1456,14 @@ keymgr_transition_time(dns_dnsseckey_t *key, int type,
 				 * actual predecessor or successor key.
 				 */
 				uint32_t tag;
-				ret = dst_key_getnum(key->key,
-						     DST_NUM_PREDECESSOR, &tag);
-				if (ret != ISC_R_SUCCESS) {
-					ret = dst_key_getnum(key->key,
-							     DST_NUM_SUCCESSOR,
-							     &tag);
+				result = dst_key_getnum(
+					key->key, DST_NUM_PREDECESSOR, &tag);
+				if (result != ISC_R_SUCCESS) {
+					result = dst_key_getnum(
+						key->key, DST_NUM_SUCCESSOR,
+						&tag);
 				}
-				if (ret == ISC_R_SUCCESS) {
+				if (result == ISC_R_SUCCESS) {
 					nexttime += dns_kasp_retiresafety(kasp);
 				}
 			}
@@ -1508,12 +1509,12 @@ transition:
 
 		/* For all records related to this key. */
 		for (int i = 0; i < NUM_KEYSTATES; i++) {
-			isc_result_t ret;
 			isc_stdtime_t when;
 			dst_key_state_t state, next_state;
 
-			ret = dst_key_getstate(dkey->key, i, &state);
-			if (ret == ISC_R_NOTFOUND) {
+			if (dst_key_getstate(dkey->key, i, &state) ==
+			    ISC_R_NOTFOUND)
+			{
 				/*
 				 * This record type is not applicable for this
 				 * key, continue to the next record type.
@@ -1664,7 +1665,7 @@ void
 dns_keymgr_key_init(dns_dnsseckey_t *key, dns_kasp_t *kasp, isc_stdtime_t now,
 		    bool csk) {
 	bool ksk, zsk;
-	isc_result_t ret;
+	isc_result_t result;
 	isc_stdtime_t active = 0, pub = 0, syncpub = 0, retire = 0, remove = 0;
 	dst_key_state_t dnskey_state = HIDDEN;
 	dst_key_state_t ds_state = HIDDEN;
@@ -1675,20 +1676,20 @@ dns_keymgr_key_init(dns_dnsseckey_t *key, dns_kasp_t *kasp, isc_stdtime_t now,
 	REQUIRE(key->key != NULL);
 
 	/* Initialize role. */
-	ret = dst_key_getbool(key->key, DST_BOOL_KSK, &ksk);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_key_getbool(key->key, DST_BOOL_KSK, &ksk);
+	if (result != ISC_R_SUCCESS) {
 		ksk = ((dst_key_flags(key->key) & DNS_KEYFLAG_KSK) != 0);
 		dst_key_setbool(key->key, DST_BOOL_KSK, ksk || csk);
 	}
-	ret = dst_key_getbool(key->key, DST_BOOL_ZSK, &zsk);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_key_getbool(key->key, DST_BOOL_ZSK, &zsk);
+	if (result != ISC_R_SUCCESS) {
 		zsk = ((dst_key_flags(key->key) & DNS_KEYFLAG_KSK) == 0);
 		dst_key_setbool(key->key, DST_BOOL_ZSK, zsk || csk);
 	}
 
 	/* Get time metadata. */
-	ret = dst_key_gettime(key->key, DST_TIME_ACTIVATE, &active);
-	if (active <= now && ret == ISC_R_SUCCESS) {
+	result = dst_key_gettime(key->key, DST_TIME_ACTIVATE, &active);
+	if (active <= now && result == ISC_R_SUCCESS) {
 		dns_ttl_t ttlsig = dns_kasp_zonemaxttl(kasp, true);
 		ttlsig += dns_kasp_zonepropagationdelay(kasp);
 		if ((active + ttlsig) <= now) {
@@ -1698,8 +1699,8 @@ dns_keymgr_key_init(dns_dnsseckey_t *key, dns_kasp_t *kasp, isc_stdtime_t now,
 		}
 		goal_state = OMNIPRESENT;
 	}
-	ret = dst_key_gettime(key->key, DST_TIME_PUBLISH, &pub);
-	if (pub <= now && ret == ISC_R_SUCCESS) {
+	result = dst_key_gettime(key->key, DST_TIME_PUBLISH, &pub);
+	if (pub <= now && result == ISC_R_SUCCESS) {
 		dns_ttl_t key_ttl = dst_key_getttl(key->key);
 		key_ttl += dns_kasp_zonepropagationdelay(kasp);
 		if ((pub + key_ttl) <= now) {
@@ -1709,8 +1710,8 @@ dns_keymgr_key_init(dns_dnsseckey_t *key, dns_kasp_t *kasp, isc_stdtime_t now,
 		}
 		goal_state = OMNIPRESENT;
 	}
-	ret = dst_key_gettime(key->key, DST_TIME_SYNCPUBLISH, &syncpub);
-	if (syncpub <= now && ret == ISC_R_SUCCESS) {
+	result = dst_key_gettime(key->key, DST_TIME_SYNCPUBLISH, &syncpub);
+	if (syncpub <= now && result == ISC_R_SUCCESS) {
 		dns_ttl_t ds_ttl = dns_kasp_dsttl(kasp);
 		ds_ttl += dns_kasp_parentpropagationdelay(kasp);
 		if ((syncpub + ds_ttl) <= now) {
@@ -1720,8 +1721,8 @@ dns_keymgr_key_init(dns_dnsseckey_t *key, dns_kasp_t *kasp, isc_stdtime_t now,
 		}
 		goal_state = OMNIPRESENT;
 	}
-	ret = dst_key_gettime(key->key, DST_TIME_INACTIVE, &retire);
-	if (retire <= now && ret == ISC_R_SUCCESS) {
+	result = dst_key_gettime(key->key, DST_TIME_INACTIVE, &result);
+	if (result <= now && result == ISC_R_SUCCESS) {
 		dns_ttl_t ttlsig = dns_kasp_zonemaxttl(kasp, true);
 		ttlsig += dns_kasp_zonepropagationdelay(kasp);
 		if ((retire + ttlsig) <= now) {
@@ -1732,8 +1733,8 @@ dns_keymgr_key_init(dns_dnsseckey_t *key, dns_kasp_t *kasp, isc_stdtime_t now,
 		ds_state = UNRETENTIVE;
 		goal_state = HIDDEN;
 	}
-	ret = dst_key_gettime(key->key, DST_TIME_DELETE, &remove);
-	if (remove <= now && ret == ISC_R_SUCCESS) {
+	result = dst_key_gettime(key->key, DST_TIME_DELETE, &remove);
+	if (remove <= now && result == ISC_R_SUCCESS) {
 		dns_ttl_t key_ttl = dst_key_getttl(key->key);
 		key_ttl += dns_kasp_zonepropagationdelay(kasp);
 		if ((remove + key_ttl) <= now) {
@@ -2087,7 +2088,7 @@ dns_keymgr_key_may_be_purged(const dst_key_t *key, uint32_t after,
 
 static void
 keymgr_purge_keyfile(dst_key_t *key, int type) {
-	isc_result_t ret;
+	isc_result_t result;
 	isc_buffer_t fileb;
 	char filename[NAME_MAX];
 
@@ -2095,8 +2096,9 @@ keymgr_purge_keyfile(dst_key_t *key, int type) {
 	 * Make the filename.
 	 */
 	isc_buffer_init(&fileb, filename, sizeof(filename));
-	ret = dst_key_buildfilename(key, type, dst_key_directory(key), &fileb);
-	if (ret != ISC_R_SUCCESS) {
+	result = dst_key_buildfilename(key, type, dst_key_directory(key),
+				       &fileb);
+	if (result != ISC_R_SUCCESS) {
 		char keystr[DST_KEY_FORMATSIZE];
 		dst_key_format(key, keystr, sizeof(keystr));
 		isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
@@ -2104,7 +2106,7 @@ keymgr_purge_keyfile(dst_key_t *key, int type) {
 			      "keymgr: failed to purge DNSKEY %s (%s): cannot "
 			      "build filename (%s)",
 			      keystr, keymgr_keyrole(key),
-			      isc_result_totext(ret));
+			      isc_result_totext(result));
 		return;
 	}
 
@@ -2134,24 +2136,23 @@ dst_key_doublematch(dns_dnsseckey_t *key, dns_kasp_t *kasp) {
 static void
 keymgr_zrrsig(dns_dnsseckeylist_t *keyring, isc_stdtime_t now) {
 	ISC_LIST_FOREACH(*keyring, dkey, link) {
-		isc_result_t ret;
+		isc_result_t result;
 		bool zsk = false;
+		dst_key_state_t state;
 
-		ret = dst_key_getbool(dkey->key, DST_BOOL_ZSK, &zsk);
-		if (ret == ISC_R_SUCCESS && zsk) {
-			dst_key_state_t state;
-			isc_result_t result = dst_key_getstate(
-				dkey->key, DST_KEY_ZRRSIG, &state);
-			if (result == ISC_R_SUCCESS) {
-				if (state == RUMOURED) {
-					dst_key_settime(dkey->key,
-							DST_TIME_SIGPUBLISH,
-							now);
-				} else if (state == UNRETENTIVE) {
-					dst_key_settime(dkey->key,
-							DST_TIME_SIGDELETE,
-							now);
-				}
+		result = dst_key_getbool(dkey->key, DST_BOOL_ZSK, &zsk);
+		if (result != ISC_R_SUCCESS || !zsk) {
+			continue;
+		}
+
+		result = dst_key_getstate(dkey->key, DST_KEY_ZRRSIG, &state);
+		if (result == ISC_R_SUCCESS) {
+			if (state == RUMOURED) {
+				dst_key_settime(dkey->key, DST_TIME_SIGPUBLISH,
+						now);
+			} else if (state == UNRETENTIVE) {
+				dst_key_settime(dkey->key, DST_TIME_SIGDELETE,
+						now);
 			}
 		}
 	}
@@ -2433,11 +2434,10 @@ keymgr_checkds(dns_kasp_t *kasp, dns_dnsseckeylist_t *keyring,
 	REQUIRE(keyring != NULL);
 
 	ISC_LIST_FOREACH(*keyring, dkey, link) {
-		isc_result_t ret;
 		bool ksk = false;
 
-		ret = dst_key_getbool(dkey->key, DST_BOOL_KSK, &ksk);
-		if (ret == ISC_R_SUCCESS && ksk) {
+		result = dst_key_getbool(dkey->key, DST_BOOL_KSK, &ksk);
+		if (result == ISC_R_SUCCESS && ksk) {
 			if (check_id && dst_key_id(dkey->key) != id) {
 				continue;
 			}
diff --git a/lib/dns/message.c b/lib/dns/message.c
index f1701c98c20..ade0e2f48d5 100644
--- a/lib/dns/message.c
+++ b/lib/dns/message.c
@@ -1572,7 +1572,7 @@ dns_message_parse(dns_message_t *msg, isc_buffer_t *source,
 		  unsigned int options) {
 	isc_region_t r;
 	dns_decompress_t dctx;
-	isc_result_t ret;
+	isc_result_t result;
 	uint16_t tmpflags;
 	isc_buffer_t origsource;
 	bool seen_problem;
@@ -1627,54 +1627,54 @@ dns_message_parse(dns_message_t *msg, isc_buffer_t *source,
 		return early_check_ret;
 	}
 
-	ret = getquestions(source, msg, dctx, options);
+	result = getquestions(source, msg, dctx, options);
 
-	if (ret == ISC_R_UNEXPECTEDEND && ignore_tc) {
+	if (result == ISC_R_UNEXPECTEDEND && ignore_tc) {
 		goto truncated;
 	}
-	if (ret == DNS_R_RECOVERABLE) {
+	if (result == DNS_R_RECOVERABLE) {
 		seen_problem = true;
-		ret = ISC_R_SUCCESS;
+		result = ISC_R_SUCCESS;
 	}
-	if (ret != ISC_R_SUCCESS) {
-		return ret;
+	if (result != ISC_R_SUCCESS) {
+		return result;
 	}
 	msg->question_ok = 1;
 
-	ret = getsection(source, msg, dctx, DNS_SECTION_ANSWER, options);
-	if (ret == ISC_R_UNEXPECTEDEND && ignore_tc) {
+	result = getsection(source, msg, dctx, DNS_SECTION_ANSWER, options);
+	if (result == ISC_R_UNEXPECTEDEND && ignore_tc) {
 		goto truncated;
 	}
-	if (ret == DNS_R_RECOVERABLE) {
+	if (result == DNS_R_RECOVERABLE) {
 		seen_problem = true;
-		ret = ISC_R_SUCCESS;
+		result = ISC_R_SUCCESS;
 	}
-	if (ret != ISC_R_SUCCESS) {
-		return ret;
+	if (result != ISC_R_SUCCESS) {
+		return result;
 	}
 
-	ret = getsection(source, msg, dctx, DNS_SECTION_AUTHORITY, options);
-	if (ret == ISC_R_UNEXPECTEDEND && ignore_tc) {
+	result = getsection(source, msg, dctx, DNS_SECTION_AUTHORITY, options);
+	if (result == ISC_R_UNEXPECTEDEND && ignore_tc) {
 		goto truncated;
 	}
-	if (ret == DNS_R_RECOVERABLE) {
+	if (result == DNS_R_RECOVERABLE) {
 		seen_problem = true;
-		ret = ISC_R_SUCCESS;
+		result = ISC_R_SUCCESS;
 	}
-	if (ret != ISC_R_SUCCESS) {
-		return ret;
+	if (result != ISC_R_SUCCESS) {
+		return result;
 	}
 
-	ret = getsection(source, msg, dctx, DNS_SECTION_ADDITIONAL, options);
-	if (ret == ISC_R_UNEXPECTEDEND && ignore_tc) {
+	result = getsection(source, msg, dctx, DNS_SECTION_ADDITIONAL, options);
+	if (result == ISC_R_UNEXPECTEDEND && ignore_tc) {
 		goto truncated;
 	}
-	if (ret == DNS_R_RECOVERABLE) {
+	if (result == DNS_R_RECOVERABLE) {
 		seen_problem = true;
-		ret = ISC_R_SUCCESS;
+		result = ISC_R_SUCCESS;
 	}
-	if (ret != ISC_R_SUCCESS) {
-		return ret;
+	if (result != ISC_R_SUCCESS) {
+		return result;
 	}
 
 	isc_buffer_remainingregion(source, &r);
@@ -1687,7 +1687,7 @@ dns_message_parse(dns_message_t *msg, isc_buffer_t *source,
 
 truncated:
 
-	if (ret == ISC_R_UNEXPECTEDEND && ignore_tc) {
+	if (result == ISC_R_UNEXPECTEDEND && ignore_tc) {
 		return DNS_R_RECOVERABLE;
 	}
 	if (seen_problem) {
diff --git a/lib/ns/query.c b/lib/ns/query.c
index b9e7ebec636..3f7f0935aa7 100644
--- a/lib/ns/query.c
+++ b/lib/ns/query.c
@@ -7441,12 +7441,11 @@ query_usestale(query_ctx_t *qctx, isc_result_t result) {
 	qctx_freedata(qctx);
 
 	if (dns_view_staleanswerenabled(qctx->client->inner.view)) {
-		isc_result_t ret;
-		ret = query_getdb(qctx->client, qctx->client->query.qname,
-				  qctx->client->query.qtype, qctx->options,
-				  &qctx->zone, &qctx->db, &qctx->version,
-				  &qctx->is_zone);
-		if (ret != ISC_R_SUCCESS) {
+		if (query_getdb(qctx->client, qctx->client->query.qname,
+				qctx->client->query.qtype, qctx->options,
+				&qctx->zone, &qctx->db, &qctx->version,
+				&qctx->is_zone) != ISC_R_SUCCESS)
+		{
 			/*
 			 * Failed to get the database, unexpected, but let us
 			 * at least abandon serve-stale.
diff --git a/tests/dns/rsa_test.c b/tests/dns/rsa_test.c
index 52d91ba16a9..fde2211356b 100644
--- a/tests/dns/rsa_test.c
+++ b/tests/dns/rsa_test.c
@@ -120,7 +120,7 @@ static unsigned char sigsha512[512] = {
 
 /* RSA verify */
 ISC_RUN_TEST_IMPL(isc_rsa_verify) {
-	isc_result_t ret;
+	isc_result_t result;
 	dns_fixedname_t fname;
 	isc_buffer_t buf;
 	dns_name_t *name;
@@ -133,30 +133,30 @@ ISC_RUN_TEST_IMPL(isc_rsa_verify) {
 	name = dns_fixedname_initname(&fname);
 	isc_buffer_constinit(&buf, "rsa.", 4);
 	isc_buffer_add(&buf, 4);
-	ret = dns_name_fromtext(name, &buf, NULL, 0);
-	assert_int_equal(ret, ISC_R_SUCCESS);
+	result = dns_name_fromtext(name, &buf, NULL, 0);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
-	ret = dst_key_fromfile(name, 29238, DST_ALG_RSASHA256, DST_TYPE_PUBLIC,
-			       TESTS_DIR, isc_g_mctx, &key);
-	assert_int_equal(ret, ISC_R_SUCCESS);
+	result = dst_key_fromfile(name, 29238, DST_ALG_RSASHA256,
+				  DST_TYPE_PUBLIC, TESTS_DIR, isc_g_mctx, &key);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	/* RSASHA1 - May not be supported by the OS */
 	if (dst_algorithm_supported(DST_ALG_RSASHA1)) {
 		key->key_alg = DST_ALG_RSASHA1;
 
-		ret = dst_context_create(key, isc_g_mctx,
-					 DNS_LOGCATEGORY_DNSSEC, false, &ctx);
-		assert_int_equal(ret, ISC_R_SUCCESS);
+		result = dst_context_create(
+			key, isc_g_mctx, DNS_LOGCATEGORY_DNSSEC, false, &ctx);
+		assert_int_equal(result, ISC_R_SUCCESS);
 
 		r.base = d;
 		r.length = 10;
-		ret = dst_context_adddata(ctx, &r);
-		assert_int_equal(ret, ISC_R_SUCCESS);
+		result = dst_context_adddata(ctx, &r);
+		assert_int_equal(result, ISC_R_SUCCESS);
 
 		r.base = sigsha1;
 		r.length = 256;
-		ret = dst_context_verify(ctx, &r);
-		assert_int_equal(ret, ISC_R_SUCCESS);
+		result = dst_context_verify(ctx, &r);
+		assert_int_equal(result, ISC_R_SUCCESS);
 
 		dst_context_destroy(&ctx);
 	}
@@ -165,19 +165,19 @@ ISC_RUN_TEST_IMPL(isc_rsa_verify) {
 
 	key->key_alg = DST_ALG_RSASHA256;
 
-	ret = dst_context_create(key, isc_g_mctx, DNS_LOGCATEGORY_DNSSEC, false,
-				 &ctx);
-	assert_int_equal(ret, ISC_R_SUCCESS);
+	result = dst_context_create(key, isc_g_mctx, DNS_LOGCATEGORY_DNSSEC,
+				    false, &ctx);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	r.base = d;
 	r.length = 10;
-	ret = dst_context_adddata(ctx, &r);
-	assert_int_equal(ret, ISC_R_SUCCESS);
+	result = dst_context_adddata(ctx, &r);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	r.base = sigsha256;
 	r.length = 256;
-	ret = dst_context_verify(ctx, &r);
-	assert_int_equal(ret, ISC_R_SUCCESS);
+	result = dst_context_verify(ctx, &r);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	dst_context_destroy(&ctx);
 
@@ -185,19 +185,19 @@ ISC_RUN_TEST_IMPL(isc_rsa_verify) {
 
 	key->key_alg = DST_ALG_RSASHA512;
 
-	ret = dst_context_create(key, isc_g_mctx, DNS_LOGCATEGORY_DNSSEC, false,
-				 &ctx);
-	assert_int_equal(ret, ISC_R_SUCCESS);
+	result = dst_context_create(key, isc_g_mctx, DNS_LOGCATEGORY_DNSSEC,
+				    false, &ctx);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	r.base = d;
 	r.length = 10;
-	ret = dst_context_adddata(ctx, &r);
-	assert_int_equal(ret, ISC_R_SUCCESS);
+	result = dst_context_adddata(ctx, &r);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	r.base = sigsha512;
 	r.length = 256;
-	ret = dst_context_verify(ctx, &r);
-	assert_int_equal(ret, ISC_R_SUCCESS);
+	result = dst_context_verify(ctx, &r);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	dst_context_destroy(&ctx);
 
diff --git a/tests/dns/skr_test.c b/tests/dns/skr_test.c
index eb2abd9b748..55b533dc520 100644
--- a/tests/dns/skr_test.c
+++ b/tests/dns/skr_test.c
@@ -122,12 +122,12 @@ print_rdata(FILE *fp, dns_rdata_t *rdata) {
 
 	isc_buffer_t target;
 	isc_region_t r;
-	isc_result_t ret;
+	isc_result_t result;
 	char buf[4096];
 
 	isc_buffer_init(&target, buf, sizeof(buf));
-	ret = dns_rdataset_totext(&rrset, dname, false, false, &target);
-	assert_int_equal(ret, ISC_R_SUCCESS);
+	result = dns_rdataset_totext(&rrset, dname, false, false, &target);
+	assert_int_equal(result, ISC_R_SUCCESS);
 	isc_buffer_usedregion(&target, &r);
 	fprintf(fp, "%.*s", (int)r.length, (char *)r.base);
 
@@ -142,13 +142,13 @@ sign_rrset(FILE *fp, isc_stdtime_t inception, isc_stdtime_t expiration,
 	   dns_rdataset_t *rrset, char *target_mem, dns_rdata_t *rrsig) {
 	dns_dnsseckey_t *ksk = ISC_LIST_HEAD(keys);
 	isc_stdtime_t clockskew = inception - OFFSET;
-	isc_result_t ret;
+	isc_result_t result;
 	isc_buffer_t target;
 
 	isc_buffer_init(&target, target_mem, 1024);
-	ret = dns_dnssec_sign(dname, rrset, ksk->key, &clockskew, &expiration,
-			      isc_g_mctx, &target, rrsig);
-	assert_int_equal(ret, ISC_R_SUCCESS);
+	result = dns_dnssec_sign(dname, rrset, ksk->key, &clockskew,
+				 &expiration, isc_g_mctx, &target, rrsig);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	print_rdata(fp, rrsig);
 }
@@ -159,7 +159,7 @@ write_record(FILE *fp, dns_rdatatype_t rdtype, const char *rdatastr,
 	isc_buffer_t source, target;
 	isc_lex_t *lex = NULL;
 	isc_lexspecials_t specials = { 0 };
-	isc_result_t ret;
+	isc_result_t result;
 
 	/* Set up source to hold the input string. */
 	isc_buffer_init(&target, target_mem, 1024);
@@ -174,12 +174,12 @@ write_record(FILE *fp, dns_rdatatype_t rdtype, const char *rdatastr,
 	specials['"'] = 1;
 	isc_lex_setspecials(lex, specials);
 	isc_lex_setcomments(lex, ISC_LEXCOMMENT_DNSMASTERFILE);
-	ret = isc_lex_openbuffer(lex, &source);
-	assert_int_equal(ret, ISC_R_SUCCESS);
+	result = isc_lex_openbuffer(lex, &source);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
-	ret = dns_rdata_fromtext(rdata, dns_rdataclass_in, rdtype, lex, dname,
-				 0, isc_g_mctx, &target, NULL);
-	assert_int_equal(ret, ISC_R_SUCCESS);
+	result = dns_rdata_fromtext(rdata, dns_rdataclass_in, rdtype, lex,
+				    dname, 0, isc_g_mctx, &target, NULL);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	print_rdata(fp, rdata);
 
@@ -196,15 +196,15 @@ create_bundle(FILE *fp, isc_stdtime_t btime, int bnum) {
 	dns_rdataset_t *cdsset = NULL;
 	isc_buffer_t b, timebuf;
 	isc_region_t r;
-	isc_result_t ret;
+	isc_result_t result;
 
 	/* Write header to file. */
 	test_bundles[bnum].btime = btime;
 	isc_buffer_init(&timebuf, timestr, sizeof(timestr));
 	isc_stdtime_tostring(btime, timestr, sizeof(timestr));
 	isc_buffer_init(&b, utc, sizeof(utc));
-	ret = dns_time32_totext(btime, &b);
-	assert_int_equal(ret, ISC_R_SUCCESS);
+	result = dns_time32_totext(btime, &b);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	isc_buffer_usedregion(&b, &r);
 	fprintf(fp, ";; SignedKeyResponse 1.0 %.*s (%s)\n", (int)r.length,
@@ -303,13 +303,13 @@ create_bundle(FILE *fp, isc_stdtime_t btime, int bnum) {
 
 static void
 check_rrsig(dns_skrbundle_t *bundle, skr__testbundle_t *tb,
-	    dns_rdatatype_t rrtype, isc_result_t ret) {
+	    dns_rdatatype_t rrtype, isc_result_t result) {
 	isc_result_t r;
 	dns_dnsseckey_t *key = ISC_LIST_HEAD(keys);
 	dns_rdata_t sigrdata = DNS_RDATA_INIT;
 
 	r = dns_skrbundle_getsig(bundle, key->key, rrtype, &sigrdata);
-	assert_int_equal(r, ret);
+	assert_int_equal(r, result);
 
 	if (r == ISC_R_SUCCESS) {
 		int cmp = 1;
@@ -399,7 +399,7 @@ check_bundle(dns_skrbundle_t *bundle, skr__testbundle_t *tb, int bnum) {
 
 static void
 create_skr_file(void) {
-	isc_result_t ret;
+	isc_result_t result;
 	isc_stdtime_t start_time;
 	size_t tempfilelen;
 	char *tempfile = NULL;
@@ -408,10 +408,10 @@ create_skr_file(void) {
 	/* Set up output file */
 	tempfilelen = strlen(TESTS_DIR "/testdata/skr/") + 20;
 	tempfile = isc_mem_get(isc_g_mctx, tempfilelen);
-	ret = isc_file_mktemplate(testskr, tempfile, tempfilelen);
-	assert_int_equal(ret, ISC_R_SUCCESS);
-	ret = isc_file_openunique(tempfile, &outfp);
-	assert_int_equal(ret, ISC_R_SUCCESS);
+	result = isc_file_mktemplate(testskr, tempfile, tempfilelen);
+	assert_int_equal(result, ISC_R_SUCCESS);
+	result = isc_file_openunique(tempfile, &outfp);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	start_time = isc_stdtime_now();
 	for (int i = 0; i < 42; i++) {
@@ -421,10 +421,10 @@ create_skr_file(void) {
 
 	fprintf(outfp, ";; SignedKeyResponse 1.0 generated by test-dev\n");
 
-	ret = isc_stdio_close(outfp);
-	assert_int_equal(ret, ISC_R_SUCCESS);
-	ret = isc_file_rename(tempfile, testskr);
-	assert_int_equal(ret, ISC_R_SUCCESS);
+	result = isc_stdio_close(outfp);
+	assert_int_equal(result, ISC_R_SUCCESS);
+	result = isc_file_rename(tempfile, testskr);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	isc_file_remove(tempfile);
 	isc_mem_put(isc_g_mctx, tempfile, tempfilelen);