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 9245fb7ceff4d3dfb8c6543bb58a9ad1a45e9b84..288b7fc85d0de9e918f634d0e9c232ae0abfd493 100644 (file)
--- 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 6c6e82f097d96f250c920c252cdbfe8e29577a81..17556b17b9c7223c59d209c786a68247acbbee8b 100644 (file)
--- 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 4502d00720ff175ef42cad08a4817a77ba450ec3..3b139ef91cea071f0d8611872b50365a25ad80da 100644 (file)
--- 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 f079dcc472ab2d589f71ddc89bcb54752c31f542..7711fb92b1cacd9fdfd79be55cff8ac6760e5865 100644 (file)
--- 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 1a9a1631911218835849879bcb350f05ef736c35..320b8adb855168685139caa3fe6f2a24ef17d0eb 100644 (file)
--- 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 76a59c225d0e88eafd617f79f33914f1fec6dfcd..f3ea00eb967e3b1bf89c5384e9ec76255d9db7d2 100644 (file)
--- 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 acb31bd322a52470e55de5b93cdce4aca9fd8439..f38936aef80aabba0e97ba3d92fa651400f3cb02 100644 (file)
--- 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 f1701c98c20a57dad19fd6bed238c80e0efa671e..ade0e2f48d529e7213681bed78e83c816d491d58 100644 (file)
--- 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 b9e7ebec636a278ce895a1047d163360de740484..3f7f0935aa73af2b949acf5c3f6940c30cbff7f8 100644 (file)
--- 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 52d91ba16a934179d818a1bdcec96d2e23da04d8..fde2211356b3a07835b89048fef95b474a0e2769 100644 (file)
--- 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 eb2abd9b74823fe7cab0008ab42a2b4c88602273..55b533dc520f15bc77fd60f7378f3cceeaa985e4 100644 (file)
--- 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);