dns_difftuple_create() cannot fail

dns_difftuple_create() could only return success, so change
its type to void and clean up all the calls to it.

other functions that only returned a result value because of it
have been cleaned up in the same way.

diff --git a/bin/dnssec/dnssec-signzone.c b/bin/dnssec/dnssec-signzone.c
index b38de8e942ff43ed215663b1c99c459a44190d6d..fed31e8139a8846641d5a11f25ce9273f73e11a8 100644 (file)
--- a/bin/dnssec/dnssec-signzone.c
+++ b/bin/dnssec/dnssec-signzone.c
@@ -320,9 +320,8 @@ signwithkey(dns_name_t *name, dns_rdataset_t *rdataset, dst_key_t *key,
        }
 
        tuple = NULL;
-       result = dns_difftuple_create(mctx, DNS_DIFFOP_ADDRESIGN, name, ttl,
-                                     &trdata, &tuple);
-       check_result(result, "dns_difftuple_create");
+       dns_difftuple_create(mctx, DNS_DIFFOP_ADDRESIGN, name, ttl, &trdata,
+                            &tuple);
        dns_diff_append(add, &tuple);
 }
 
@@ -634,24 +633,20 @@ signset(dns_diff_t *del, dns_diff_t *add, dns_dbnode_t *node, dns_name_t *name,
                        if (sigset.ttl != ttl) {
                                vbprintf(2, "\tfixing ttl %s\n", sigstr);
                                tuple = NULL;
-                               result = dns_difftuple_create(
-                                       mctx, DNS_DIFFOP_DELRESIGN, name,
-                                       sigset.ttl, &sigrdata, &tuple);
-                               check_result(result, "dns_difftuple_create");
+                               dns_difftuple_create(mctx, DNS_DIFFOP_DELRESIGN,
+                                                    name, sigset.ttl,
+                                                    &sigrdata, &tuple);
                                dns_diff_append(del, &tuple);
-                               result = dns_difftuple_create(
-                                       mctx, DNS_DIFFOP_ADDRESIGN, name, ttl,
-                                       &sigrdata, &tuple);
-                               check_result(result, "dns_difftuple_create");
+                               dns_difftuple_create(mctx, DNS_DIFFOP_ADDRESIGN,
+                                                    name, ttl, &sigrdata,
+                                                    &tuple);
                                dns_diff_append(add, &tuple);
                        }
                } else {
                        tuple = NULL;
                        vbprintf(2, "\tremoving signature by %s\n", sigstr);
-                       result = dns_difftuple_create(
-                               mctx, DNS_DIFFOP_DELRESIGN, name, sigset.ttl,
-                               &sigrdata, &tuple);
-                       check_result(result, "dns_difftuple_create");
+                       dns_difftuple_create(mctx, DNS_DIFFOP_DELRESIGN, name,
+                                            sigset.ttl, &sigrdata, &tuple);
                        dns_diff_append(del, &tuple);
                        INCSTAT(ndropped);
                }
@@ -1080,9 +1075,8 @@ loadds(dns_name_t *name, uint32_t ttl, dns_rdataset_t *dsset) {
                                           dsbuf, &ds);
                check_result(result, "dns_ds_buildrdata");
 
-               result = dns_difftuple_create(mctx, DNS_DIFFOP_ADDRESIGN, name,
-                                             ttl, &ds, &tuple);
-               check_result(result, "dns_difftuple_create");
+               dns_difftuple_create(mctx, DNS_DIFFOP_ADDRESIGN, name, ttl, &ds,
+                                    &tuple);
                dns_diff_append(&diff, &tuple);
        }
 
@@ -2201,10 +2195,9 @@ rrset_cleanup(dns_name_t *name, dns_rdataset_t *rdataset, dns_diff_t *add,
                        {
                                vbprintf(2, "removing duplicate at %s/%s\n",
                                         namestr, typestr);
-                               result = dns_difftuple_create(
-                                       mctx, DNS_DIFFOP_DELRESIGN, name,
-                                       rdataset->ttl, &rdata2, &tuple);
-                               check_result(result, "dns_difftuple_create");
+                               dns_difftuple_create(mctx, DNS_DIFFOP_DELRESIGN,
+                                                    name, rdataset->ttl,
+                                                    &rdata2, &tuple);
                                dns_diff_append(del, &tuple);
                        } else if (set_maxttl && rdataset->ttl > maxttl) {
                                vbprintf(2,
@@ -2212,16 +2205,14 @@ rrset_cleanup(dns_name_t *name, dns_rdataset_t *rdataset, dns_diff_t *add,
                                         "from %d to %d\n",
                                         namestr, typestr, rdataset->ttl,
                                         maxttl);
-                               result = dns_difftuple_create(
-                                       mctx, DNS_DIFFOP_DELRESIGN, name,
-                                       rdataset->ttl, &rdata2, &tuple);
-                               check_result(result, "dns_difftuple_create");
+                               dns_difftuple_create(mctx, DNS_DIFFOP_DELRESIGN,
+                                                    name, rdataset->ttl,
+                                                    &rdata2, &tuple);
                                dns_diff_append(del, &tuple);
                                tuple = NULL;
-                               result = dns_difftuple_create(
-                                       mctx, DNS_DIFFOP_ADDRESIGN, name,
-                                       maxttl, &rdata2, &tuple);
-                               check_result(result, "dns_difftuple_create");
+                               dns_difftuple_create(mctx, DNS_DIFFOP_ADDRESIGN,
+                                                    name, maxttl, &rdata2,
+                                                    &tuple);
                                dns_diff_append(add, &tuple);
                        }
                }
@@ -3154,15 +3145,13 @@ writeset(const char *prefix, dns_rdatatype_t type) {
                                                   DNS_DSDIGEST_SHA256, dsbuf,
                                                   &ds);
                        check_result(result, "dns_ds_buildrdata");
-                       result = dns_difftuple_create(mctx,
-                                                     DNS_DIFFOP_ADDRESIGN,
-                                                     name, 0, &ds, &tuple);
+                       dns_difftuple_create(mctx, DNS_DIFFOP_ADDRESIGN, name,
+                                            0, &ds, &tuple);
                } else {
-                       result = dns_difftuple_create(
-                               mctx, DNS_DIFFOP_ADDRESIGN, gorigin,
-                               zone_soa_min_ttl, &rdata, &tuple);
+                       dns_difftuple_create(mctx, DNS_DIFFOP_ADDRESIGN,
+                                            gorigin, zone_soa_min_ttl, &rdata,
+                                            &tuple);
                }
-               check_result(result, "dns_difftuple_create");
                dns_diff_append(&diff, &tuple);
        }
 

diff --git a/bin/tests/system/dyndb/driver/syncptr.c b/bin/tests/system/dyndb/driver/syncptr.c
index 364fa670ee605c6e7e5b84f2b9089ff18e7dfd08..6e232e29024b2d16828f3fb447c1d37bd286feed 100644 (file)
--- a/bin/tests/system/dyndb/driver/syncptr.c
+++ b/bin/tests/system/dyndb/driver/syncptr.c
@@ -259,14 +259,8 @@ syncptr(sample_instance_t *inst, dns_name_t *name, dns_rdata_t *addr_rdata,
        }
 
        /* Create diff */
-       result = dns_difftuple_create(mctx, op, dns_fixedname_name(&ptr_name),
-                                     ttl, &ptr_rdata, &tp);
-       if (result != ISC_R_SUCCESS) {
-               log_write(ISC_LOG_ERROR,
-                         "syncptr: dns_difftuple_create -> %s\n",
-                         isc_result_totext(result));
-               goto cleanup;
-       }
+       dns_difftuple_create(mctx, op, dns_fixedname_name(&ptr_name), ttl,
+                            &ptr_rdata, &tp);
        dns_diff_append(&syncptr->diff, &tp);
 
        /*

diff --git a/lib/dns/diff.c b/lib/dns/diff.c
index efefbaa2a0bddde289f8c9617ed37b687585a84b..b25c77f7c51aceb504fa17d5679a755327f08637 100644 (file)
--- a/lib/dns/diff.c
+++ b/lib/dns/diff.c
@@ -51,7 +51,7 @@ rdata_covers(dns_rdata_t *rdata) {
                                                   : 0);
 }
 
-isc_result_t
+void
 dns_difftuple_create(isc_mem_t *mctx, dns_diffop_t op, const dns_name_t *name,
                     dns_ttl_t ttl, dns_rdata_t *rdata, dns_difftuple_t **tp) {
        dns_difftuple_t *t;
@@ -99,7 +99,6 @@ dns_difftuple_create(isc_mem_t *mctx, dns_diffop_t op, const dns_name_t *name,
        INSIST(datap == (unsigned char *)t + size);
 
        *tp = t;
-       return (ISC_R_SUCCESS);
 }
 
 void
@@ -117,10 +116,10 @@ dns_difftuple_free(dns_difftuple_t **tp) {
        isc_mem_detach(&mctx);
 }
 
-isc_result_t
+void
 dns_difftuple_copy(dns_difftuple_t *orig, dns_difftuple_t **copyp) {
-       return (dns_difftuple_create(orig->mctx, orig->op, &orig->name,
-                                    orig->ttl, &orig->rdata, copyp));
+       dns_difftuple_create(orig->mctx, orig->op, &orig->name, orig->ttl,
+                            &orig->rdata, copyp);
 }
 
 void

diff --git a/lib/dns/dnssec.c b/lib/dns/dnssec.c
index eaf7ef6f11c89f93497310b997554b2eab1f64ed..ffb033b0083908fcffe9acbf7a5acf4c28b440e3 100644 (file)
--- a/lib/dns/dnssec.c
+++ b/lib/dns/dnssec.c
@@ -1750,39 +1750,29 @@ dns_dnssec_make_dnskey(dst_key_t *key, unsigned char *buf, int bufsize,
        return (ISC_R_SUCCESS);
 }
 
-static isc_result_t
+static void
 addrdata(dns_rdata_t *rdata, dns_diff_t *diff, const dns_name_t *origin,
         dns_ttl_t ttl, isc_mem_t *mctx) {
-       isc_result_t result;
        dns_difftuple_t *tuple = NULL;
 
-       RETERR(dns_difftuple_create(mctx, DNS_DIFFOP_ADD, origin, ttl, rdata,
-                                   &tuple));
+       dns_difftuple_create(mctx, DNS_DIFFOP_ADD, origin, ttl, rdata, &tuple);
        dns_diff_appendminimal(diff, &tuple);
-
-failure:
-       return (result);
 }
 
-static isc_result_t
+static void
 delrdata(dns_rdata_t *rdata, dns_diff_t *diff, const dns_name_t *origin,
         dns_ttl_t ttl, isc_mem_t *mctx) {
-       isc_result_t result;
        dns_difftuple_t *tuple = NULL;
 
-       RETERR(dns_difftuple_create(mctx, DNS_DIFFOP_DEL, origin, ttl, rdata,
-                                   &tuple));
+       dns_difftuple_create(mctx, DNS_DIFFOP_DEL, origin, ttl, rdata, &tuple);
        dns_diff_appendminimal(diff, &tuple);
-
-failure:
-       return (result);
 }
 
 static isc_result_t
 publish_key(dns_diff_t *diff, dns_dnsseckey_t *key, const dns_name_t *origin,
            dns_ttl_t ttl, isc_mem_t *mctx,
            void (*report)(const char *, ...) ISC_FORMAT_PRINTF(1, 2)) {
-       isc_result_t result;
+       isc_result_t result = ISC_R_SUCCESS;
        unsigned char buf[DST_KEY_MAXSIZE];
        char keystr[DST_KEY_FORMATSIZE];
        dns_rdata_t dnskey = DNS_RDATA_INIT;
@@ -1807,7 +1797,7 @@ publish_key(dns_diff_t *diff, dns_dnsseckey_t *key, const dns_name_t *origin,
        }
 
        /* publish key */
-       result = addrdata(&dnskey, diff, origin, ttl, mctx);
+       addrdata(&dnskey, diff, origin, ttl, mctx);
 
 failure:
        return (result);
@@ -1817,7 +1807,7 @@ static isc_result_t
 remove_key(dns_diff_t *diff, dns_dnsseckey_t *key, const dns_name_t *origin,
           dns_ttl_t ttl, isc_mem_t *mctx, const char *reason,
           void (*report)(const char *, ...) ISC_FORMAT_PRINTF(1, 2)) {
-       isc_result_t result;
+       isc_result_t result = ISC_R_SUCCESS;
        unsigned char buf[DST_KEY_MAXSIZE];
        dns_rdata_t dnskey = DNS_RDATA_INIT;
        char alg[80];
@@ -1829,7 +1819,7 @@ remove_key(dns_diff_t *diff, dns_dnsseckey_t *key, const dns_name_t *origin,
               dst_key_id(key->key), alg);
 
        RETERR(dns_dnssec_make_dnskey(key->key, buf, sizeof(buf), &dnskey));
-       result = delrdata(&dnskey, diff, origin, ttl, mctx);
+       delrdata(&dnskey, diff, origin, ttl, mctx);
 
 failure:
        return (result);
@@ -1861,7 +1851,7 @@ static isc_result_t
 add_cds(dns_dnsseckey_t *key, dns_rdata_t *keyrdata, const char *keystr,
        dns_rdataset_t *cds, unsigned int digesttype, dns_ttl_t ttl,
        dns_diff_t *diff, isc_mem_t *mctx) {
-       isc_result_t r = ISC_R_SUCCESS;
+       isc_result_t r;
        unsigned char dsbuf[DNS_DS_BUFFERSIZE];
        dns_rdata_t cdsrdata = DNS_RDATA_INIT;
        dns_name_t *origin = dst_key_name(key->key);
@@ -1887,16 +1877,16 @@ add_cds(dns_dnsseckey_t *key, dns_rdata_t *keyrdata, const char *keystr,
                              DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
                              "CDS (%s) for key %s is now published", algbuf,
                              keystr);
-               r = addrdata(&cdsrdata, diff, origin, ttl, mctx);
+               addrdata(&cdsrdata, diff, origin, ttl, mctx);
        }
-       return (r);
+       return (ISC_R_SUCCESS);
 }
 
 static isc_result_t
 delete_cds(dns_dnsseckey_t *key, dns_rdata_t *keyrdata, const char *keystr,
           dns_rdataset_t *cds, unsigned int digesttype, dns_diff_t *diff,
           isc_mem_t *mctx) {
-       isc_result_t r = ISC_R_SUCCESS;
+       isc_result_t r;
        unsigned char dsbuf[DNS_DS_BUFFERSIZE];
        dns_rdata_t cdsrdata = DNS_RDATA_INIT;
        dns_name_t *origin = dst_key_name(key->key);
@@ -1915,9 +1905,9 @@ delete_cds(dns_dnsseckey_t *key, dns_rdata_t *keyrdata, const char *keystr,
                              DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
                              "CDS (%s) for key %s is now deleted", algbuf,
                              keystr);
-               r = delrdata(&cdsrdata, diff, origin, cds->ttl, mctx);
+               delrdata(&cdsrdata, diff, origin, cds->ttl, mctx);
        }
-       return (r);
+       return (ISC_R_SUCCESS);
 }
 
 isc_result_t
@@ -1976,8 +1966,8 @@ dns_dnssec_syncupdate(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *rmkeys,
                                        DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
                                        "CDNSKEY for key %s is now published",
                                        keystr);
-                               RETERR(addrdata(&cdnskeyrdata, diff, origin,
-                                               cdnskeyttl, mctx));
+                               addrdata(&cdnskeyrdata, diff, origin,
+                                        cdnskeyttl, mctx);
                        }
                }
 
@@ -2007,9 +1997,8 @@ dns_dnssec_syncupdate(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *rmkeys,
                                                      "CDNSKEY for key %s is "
                                                      "now deleted",
                                                      keystr);
-                                       RETERR(delrdata(&cdnskeyrdata, diff,
-                                                       origin, cdnskey->ttl,
-                                                       mctx));
+                                       delrdata(&cdnskeyrdata, diff, origin,
+                                                cdnskey->ttl, mctx);
                                }
                        }
                }
@@ -2052,8 +2041,8 @@ dns_dnssec_syncupdate(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *rmkeys,
                                        DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
                                        "CDNSKEY for key %s is now deleted",
                                        keystr);
-                               RETERR(delrdata(&cdnskeyrdata, diff, origin,
-                                               cdnskey->ttl, mctx));
+                               delrdata(&cdnskeyrdata, diff, origin,
+                                        cdnskey->ttl, mctx);
                        }
                }
        }
@@ -2075,7 +2064,6 @@ dns_dnssec_syncdelete(dns_rdataset_t *cds, dns_rdataset_t *cdnskey,
        dns_rdata_t cds_delete = DNS_RDATA_INIT;
        dns_rdata_t cdnskey_delete = DNS_RDATA_INIT;
        isc_region_t r;
-       isc_result_t result;
 
        r.base = keybuf;
        r.length = sizeof(keybuf);
@@ -2097,7 +2085,7 @@ dns_dnssec_syncdelete(dns_rdataset_t *cds, dns_rdataset_t *cdnskey,
                                      "CDS (DELETE) for zone %s is now "
                                      "published",
                                      namebuf);
-                       RETERR(addrdata(&cds_delete, diff, origin, ttl, mctx));
+                       addrdata(&cds_delete, diff, origin, ttl, mctx);
                }
        } else {
                if (dns_rdataset_isassociated(cds) && exists(cds, &cds_delete))
@@ -2107,8 +2095,7 @@ dns_dnssec_syncdelete(dns_rdataset_t *cds, dns_rdataset_t *cdnskey,
                                      "CDS (DELETE) for zone %s is now "
                                      "deleted",
                                      namebuf);
-                       RETERR(delrdata(&cds_delete, diff, origin, cds->ttl,
-                                       mctx));
+                       delrdata(&cds_delete, diff, origin, cds->ttl, mctx);
                }
        }
 
@@ -2121,8 +2108,7 @@ dns_dnssec_syncdelete(dns_rdataset_t *cds, dns_rdataset_t *cdnskey,
                                      "CDNSKEY (DELETE) for zone %s is now "
                                      "published",
                                      namebuf);
-                       RETERR(addrdata(&cdnskey_delete, diff, origin, ttl,
-                                       mctx));
+                       addrdata(&cdnskey_delete, diff, origin, ttl, mctx);
                }
        } else {
                if (dns_rdataset_isassociated(cdnskey) &&
@@ -2133,15 +2119,12 @@ dns_dnssec_syncdelete(dns_rdataset_t *cds, dns_rdataset_t *cdnskey,
                                      "CDNSKEY (DELETE) for zone %s is now "
                                      "deleted",
                                      namebuf);
-                       RETERR(delrdata(&cdnskey_delete, diff, origin,
-                                       cdnskey->ttl, mctx));
+                       delrdata(&cdnskey_delete, diff, origin, cdnskey->ttl,
+                                mctx);
                }
        }
 
-       result = ISC_R_SUCCESS;
-
-failure:
-       return (result);
+       return (ISC_R_SUCCESS);
 }
 
 /*

diff --git a/lib/dns/include/dns/diff.h b/lib/dns/include/dns/diff.h
index 3bda5644d6eb7a9c1135f251265f20810076d691..5b5cc1f0c4a890e689988f95c1f7ca4287e1d7ef 100644 (file)
--- a/lib/dns/include/dns/diff.h
+++ b/lib/dns/include/dns/diff.h
@@ -114,7 +114,7 @@ ISC_LANG_BEGINDECLS
  * Manipulation of diffs and tuples.
  */
 
-isc_result_t
+void
 dns_difftuple_create(isc_mem_t *mctx, dns_diffop_t op, const dns_name_t *name,
                     dns_ttl_t ttl, dns_rdata_t *rdata, dns_difftuple_t **tp);
 /*%<
@@ -123,10 +123,6 @@ dns_difftuple_create(isc_mem_t *mctx, dns_diffop_t op, const dns_name_t *name,
  *
  * Requires:
  *\li  *tp != NULL && *tp == NULL.
- *
- * Returns:
- *\li  ISC_R_SUCCESS
- *  \li    ISC_R_NOMEMORY
  */
 
 void
@@ -142,14 +138,14 @@ dns_difftuple_free(dns_difftuple_t **tp);
  *      \li All memory used by the tuple is freed.
  */
 
-isc_result_t
+void
 dns_difftuple_copy(dns_difftuple_t *orig, dns_difftuple_t **copyp);
 /*%<
  * Copy a tuple.
  *
  * Requires:
  * \li 'orig' points to a valid tuple
- *\li  copyp != NULL && *copyp == NULL
+ * \li copyp != NULL && *copyp == NULL
  */
 
 void

diff --git a/lib/dns/journal.c b/lib/dns/journal.c
index 604766d56f91fdab9b3bdcff9e7a06d33f55391f..0d7b4a7904b2a8a20bab2012503e996adba699cb 100644 (file)
--- a/lib/dns/journal.c
+++ b/lib/dns/journal.c
@@ -158,8 +158,7 @@ dns_db_createsoatuple(dns_db_t *db, dns_dbversion_t *ver, isc_mem_t *mctx,
        dns_rdataset_current(&rdataset, &rdata);
        dns_rdataset_getownercase(&rdataset, zonename);
 
-       result = dns_difftuple_create(mctx, op, zonename, rdataset.ttl, &rdata,
-                                     tp);
+       dns_difftuple_create(mctx, op, zonename, rdataset.ttl, &rdata, tp);
 
        dns_rdataset_disassociate(&rdataset);
        dns_db_detachnode(db, &node);
@@ -1575,8 +1574,7 @@ dns_journal_rollforward(dns_journal_t *j, dns_db_t *db, unsigned int options) {
                        op = (n_soa == 1) ? DNS_DIFFOP_DEL : DNS_DIFFOP_ADD;
                }
 
-               CHECK(dns_difftuple_create(diff.mctx, op, name, ttl, rdata,
-                                          &tuple));
+               dns_difftuple_create(diff.mctx, op, name, ttl, rdata, &tuple);
                dns_diff_append(&diff, &tuple);
 
                if (++n_put > 100) {
@@ -1728,9 +1726,9 @@ dns_journal_print(isc_mem_t *mctx, uint32_t flags, const char *filename,
                                i++;
                        }
                }
-               CHECK(dns_difftuple_create(
+               dns_difftuple_create(
                        diff.mctx, n_soa == 1 ? DNS_DIFFOP_DEL : DNS_DIFFOP_ADD,
-                       name, ttl, rdata, &tuple));
+                       name, ttl, rdata, &tuple);
                dns_diff_append(&diff, &tuple);
 
                if (++n_put > 100 || printxhdr) {
@@ -2147,13 +2145,8 @@ get_name_diff(dns_db_t *db, dns_dbversion_t *ver, isc_stdtime_t now,
                {
                        dns_rdata_t rdata = DNS_RDATA_INIT;
                        dns_rdataset_current(&rdataset, &rdata);
-                       result = dns_difftuple_create(diff->mctx, op, name,
-                                                     rdataset.ttl, &rdata,
-                                                     &tuple);
-                       if (result != ISC_R_SUCCESS) {
-                               dns_rdataset_disassociate(&rdataset);
-                               goto cleanup_iterator;
-                       }
+                       dns_difftuple_create(diff->mctx, op, name, rdataset.ttl,
+                                            &rdata, &tuple);
                        dns_diff_append(diff, &tuple);
                }
                dns_rdataset_disassociate(&rdataset);

diff --git a/lib/dns/nsec3.c b/lib/dns/nsec3.c
index acecc41233a4d4ee6d7cd7df03af5ca07d080e30..e92557e0025658275b5e9804855ea278fc7208dc 100644 (file)
--- a/lib/dns/nsec3.c
+++ b/lib/dns/nsec3.c
@@ -442,11 +442,8 @@ delnsec3(dns_db_t *db, dns_dbversion_t *version, const dns_name_t *name,
                        continue;
                }
 
-               result = dns_difftuple_create(diff->mctx, DNS_DIFFOP_DEL, name,
-                                             rdataset.ttl, &rdata, &tuple);
-               if (result != ISC_R_SUCCESS) {
-                       goto failure;
-               }
+               dns_difftuple_create(diff->mctx, DNS_DIFFOP_DEL, name,
+                                    rdataset.ttl, &rdata, &tuple);
                result = do_one_tuple(&tuple, db, version, diff);
                if (result != ISC_R_SUCCESS) {
                        goto failure;
@@ -720,8 +717,8 @@ dns_nsec3_addnsec3(dns_db_t *db, dns_dbversion_t *version,
                CHECK(dns_rdata_fromstruct(&rdata, rdataset.rdclass,
                                           dns_rdatatype_nsec3, &nsec3,
                                           &buffer));
-               CHECK(dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, prev,
-                                          rdataset.ttl, &rdata, &tuple));
+               dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, prev,
+                                    rdataset.ttl, &rdata, &tuple);
                CHECK(do_one_tuple(&tuple, db, version, diff));
                INSIST(old_length <= sizeof(nexthash));
                memmove(nexthash, old_next, old_length);
@@ -750,8 +747,8 @@ addnsec3:
        /*
         * Add the new NSEC3 and record the change.
         */
-       CHECK(dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, hashname,
-                                  nsecttl, &rdata, &tuple));
+       dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, hashname, nsecttl,
+                            &rdata, &tuple);
        CHECK(do_one_tuple(&tuple, db, version, diff));
        INSIST(tuple == NULL);
        dns_rdata_reset(&rdata);
@@ -843,9 +840,8 @@ addnsec3:
                        CHECK(dns_rdata_fromstruct(&rdata, rdataset.rdclass,
                                                   dns_rdatatype_nsec3, &nsec3,
                                                   &buffer));
-                       CHECK(dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD,
-                                                  prev, rdataset.ttl, &rdata,
-                                                  &tuple));
+                       dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, prev,
+                                            rdataset.ttl, &rdata, &tuple);
                        CHECK(do_one_tuple(&tuple, db, version, diff));
                        INSIST(old_length <= sizeof(nexthash));
                        memmove(nexthash, old_next, old_length);
@@ -873,8 +869,8 @@ addnsec3:
                /*
                 * Add the new NSEC3 and record the change.
                 */
-               CHECK(dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, hashname,
-                                          nsecttl, &rdata, &tuple));
+               dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, hashname,
+                                    nsecttl, &rdata, &tuple);
                CHECK(do_one_tuple(&tuple, db, version, diff));
                INSIST(tuple == NULL);
                dns_rdata_reset(&rdata);
@@ -1143,9 +1139,8 @@ dns_nsec3param_deletechains(dns_db_t *db, dns_dbversion_t *ver,
                CHECK(rr_exists(db, ver, origin, &private, &flag));
 
                if (!flag) {
-                       CHECK(dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD,
-                                                  origin, 0, &private,
-                                                  &tuple));
+                       dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, origin,
+                                            0, &private, &tuple);
                        CHECK(do_one_tuple(&tuple, db, ver, diff));
                        INSIST(tuple == NULL);
                }
@@ -1189,8 +1184,8 @@ try_private:
                        continue;
                }
 
-               CHECK(dns_difftuple_create(diff->mctx, DNS_DIFFOP_DEL, origin,
-                                          0, &rdata, &tuple));
+               dns_difftuple_create(diff->mctx, DNS_DIFFOP_DEL, origin, 0,
+                                    &rdata, &tuple);
                CHECK(do_one_tuple(&tuple, db, ver, diff));
                INSIST(tuple == NULL);
 
@@ -1203,8 +1198,8 @@ try_private:
                CHECK(rr_exists(db, ver, origin, &rdata, &flag));
 
                if (!flag) {
-                       CHECK(dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD,
-                                                  origin, 0, &rdata, &tuple));
+                       dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, origin,
+                                            0, &rdata, &tuple);
                        CHECK(do_one_tuple(&tuple, db, ver, diff));
                        INSIST(tuple == NULL);
                }
@@ -1513,8 +1508,8 @@ dns_nsec3_delnsec3(dns_db_t *db, dns_dbversion_t *version,
                CHECK(dns_rdata_fromstruct(&rdata, rdataset.rdclass,
                                           dns_rdatatype_nsec3, &nsec3,
                                           &buffer));
-               CHECK(dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, prev,
-                                          rdataset.ttl, &rdata, &tuple));
+               dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, prev,
+                                    rdataset.ttl, &rdata, &tuple);
                CHECK(do_one_tuple(&tuple, db, version, diff));
                dns_rdata_reset(&rdata);
                dns_rdataset_disassociate(&rdataset);
@@ -1620,9 +1615,8 @@ cleanup_orphaned_ents:
                        CHECK(dns_rdata_fromstruct(&rdata, rdataset.rdclass,
                                                   dns_rdatatype_nsec3, &nsec3,
                                                   &buffer));
-                       CHECK(dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD,
-                                                  prev, rdataset.ttl, &rdata,
-                                                  &tuple));
+                       dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, prev,
+                                            rdataset.ttl, &rdata, &tuple);
                        CHECK(do_one_tuple(&tuple, db, version, diff));
                        dns_rdata_reset(&rdata);
                        dns_rdataset_disassociate(&rdataset);

diff --git a/lib/dns/update.c b/lib/dns/update.c
index a6b8f2adf4ad3306b02f55d539fc72edde356d96..0deef07b4b2c01e250b7b421af027e1d79fe856a 100644 (file)
--- a/lib/dns/update.c
+++ b/lib/dns/update.c
@@ -265,11 +265,7 @@ update_one_rr(dns_db_t *db, dns_dbversion_t *ver, dns_diff_t *diff,
              dns_diffop_t op, dns_name_t *name, dns_ttl_t ttl,
              dns_rdata_t *rdata) {
        dns_difftuple_t *tuple = NULL;
-       isc_result_t result;
-       result = dns_difftuple_create(diff->mctx, op, name, ttl, rdata, &tuple);
-       if (result != ISC_R_SUCCESS) {
-               return (result);
-       }
+       dns_difftuple_create(diff->mctx, op, name, ttl, rdata, &tuple);
        return (do_one_tuple(&tuple, db, ver, diff));
 }
 
@@ -724,17 +720,14 @@ delete_if(rr_predicate *predicate, dns_db_t *db, dns_dbversion_t *ver,
  * We abuse the dns_diff_t type to represent a set of domain names
  * affected by the update.
  */
-static isc_result_t
+static void
 namelist_append_name(dns_diff_t *list, dns_name_t *name) {
-       isc_result_t result;
        dns_difftuple_t *tuple = NULL;
        static dns_rdata_t dummy_rdata = DNS_RDATA_INIT;
 
-       CHECK(dns_difftuple_create(list->mctx, DNS_DIFFOP_EXISTS, name, 0,
-                                  &dummy_rdata, &tuple));
+       dns_difftuple_create(list->mctx, DNS_DIFFOP_EXISTS, name, 0,
+                            &dummy_rdata, &tuple);
        dns_diff_append(list, &tuple);
-failure:
-       return (result);
 }
 
 static isc_result_t
@@ -758,7 +751,7 @@ namelist_append_subdomain(dns_db_t *db, dns_name_t *name,
                if (!dns_name_issubdomain(child, name)) {
                        break;
                }
-               CHECK(namelist_append_name(affected, child));
+               namelist_append_name(affected, child);
        }
        if (result == ISC_R_NOMORE) {
                result = ISC_R_SUCCESS;
@@ -1014,8 +1007,8 @@ add_nsec(dns_update_log_t *log, dns_zone_t *zone, dns_db_t *db,
        /*
         * Add the new NSEC and record the change.
         */
-       CHECK(dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, name, nsecttl,
-                                  &rdata, &tuple));
+       dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, name, nsecttl, &rdata,
+                            &tuple);
        CHECK(do_one_tuple(&tuple, db, ver, diff));
        INSIST(tuple == NULL);
 
@@ -1041,8 +1034,8 @@ add_placeholder_nsec(dns_db_t *db, dns_dbversion_t *ver, dns_name_t *name,
        r.base = data;
        r.length = sizeof(data);
        dns_rdata_fromregion(&rdata, dns_db_class(db), dns_rdatatype_nsec, &r);
-       CHECK(dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, name, 0, &rdata,
-                                  &tuple));
+       dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, name, 0, &rdata,
+                            &tuple);
        CHECK(do_one_tuple(&tuple, db, ver, diff));
 failure:
        return (result);
@@ -1608,7 +1601,7 @@ next_state:
                         * update.
                         */
 
-                       CHECK(namelist_append_name(&state->diffnames, name));
+                       namelist_append_name(&state->diffnames, name);
 
                        while (t != NULL && dns_name_equal(&t->name, name)) {
                                dns_rdatatype_t type;
@@ -1761,7 +1754,7 @@ next_state:
                         */
                        CHECK(next_active(log, zone, db, newver, &t->name,
                                          prevname, false));
-                       CHECK(namelist_append_name(&state->affected, prevname));
+                       namelist_append_name(&state->affected, prevname);
                }
 
                /*
@@ -2011,7 +2004,7 @@ next_state:
                                continue;
                        }
 
-                       CHECK(namelist_append_name(&state->affected, name));
+                       namelist_append_name(&state->affected, name);
 
                        if (oldver != NULL) {
                                CHECK(rrset_exists(db, oldver, name,

diff --git a/lib/dns/xfrin.c b/lib/dns/xfrin.c
index 523b59a5a656a7a890146212a0d79737d6c87205..f321924728a9cf28098d2f5ace557f61a5202018 100644 (file)
--- a/lib/dns/xfrin.c
+++ b/lib/dns/xfrin.c
@@ -308,8 +308,7 @@ axfr_putdata(dns_xfrin_t *xfr, dns_diffop_t op, dns_name_t *name, dns_ttl_t ttl,
        }
 
        CHECK(dns_zone_checknames(xfr->zone, name, rdata));
-       CHECK(dns_difftuple_create(xfr->diff.mctx, op, name, ttl, rdata,
-                                  &tuple));
+       dns_difftuple_create(xfr->diff.mctx, op, name, ttl, rdata, &tuple);
        dns_diff_append(&xfr->diff, &tuple);
        result = ISC_R_SUCCESS;
 failure:
@@ -445,7 +444,7 @@ failure:
 static isc_result_t
 ixfr_putdata(dns_xfrin_t *xfr, dns_diffop_t op, dns_name_t *name, dns_ttl_t ttl,
             dns_rdata_t *rdata) {
-       isc_result_t result;
+       isc_result_t result = ISC_R_SUCCESS;
        dns_difftuple_t *tuple = NULL;
 
        if (rdata->rdclass != xfr->rdclass) {
@@ -455,10 +454,10 @@ ixfr_putdata(dns_xfrin_t *xfr, dns_diffop_t op, dns_name_t *name, dns_ttl_t ttl,
        if (op == DNS_DIFFOP_ADD) {
                CHECK(dns_zone_checknames(xfr->zone, name, rdata));
        }
-       CHECK(dns_difftuple_create(xfr->diff.mctx, op, name, ttl, rdata,
-                                  &tuple));
+
+       dns_difftuple_create(xfr->diff.mctx, op, name, ttl, rdata, &tuple);
        dns_diff_append(&xfr->diff, &tuple);
-       result = ISC_R_SUCCESS;
+
 failure:
        return (result);
 }

diff --git a/lib/dns/zone.c b/lib/dns/zone.c
index 0bf4b6b865a68f5d10dca0fed5421194c8884bfb..8336f27485543a0770ff9156a74c2af8c84739a7 100644 (file)
--- a/lib/dns/zone.c
+++ b/lib/dns/zone.c
@@ -4281,11 +4281,8 @@ update_one_rr(dns_db_t *db, dns_dbversion_t *ver, dns_diff_t *diff,
              dns_diffop_t op, dns_name_t *name, dns_ttl_t ttl,
              dns_rdata_t *rdata) {
        dns_difftuple_t *tuple = NULL;
-       isc_result_t result;
-       result = dns_difftuple_create(diff->mctx, op, name, ttl, rdata, &tuple);
-       if (result != ISC_R_SUCCESS) {
-               return (result);
-       }
+
+       dns_difftuple_create(diff->mctx, op, name, ttl, rdata, &tuple);
        return (do_one_tuple(&tuple, db, ver, diff));
 }
 
@@ -4302,7 +4299,7 @@ update_soa_serial(dns_zone_t *zone, dns_db_t *db, dns_dbversion_t *ver,
        INSIST(method != dns_updatemethod_none);
 
        CHECK(dns_db_createsoatuple(db, ver, mctx, DNS_DIFFOP_DEL, &deltuple));
-       CHECK(dns_difftuple_copy(deltuple, &addtuple));
+       dns_difftuple_copy(deltuple, &addtuple);
        addtuple->op = DNS_DIFFOP_ADD;
 
        serial = dns_soa_getserial(&addtuple->rdata);
@@ -16241,9 +16238,9 @@ sync_secure_journal(dns_zone_t *zone, dns_zone_t *raw, dns_journal_t *journal,
                                if (*soatuplep != NULL) {
                                        dns_difftuple_free(soatuplep);
                                }
-                               CHECK(dns_difftuple_create(
-                                       diff->mctx, DNS_DIFFOP_ADD, name, ttl,
-                                       rdata, soatuplep));
+                               dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD,
+                                                    name, ttl, rdata,
+                                                    soatuplep);
                        }
                        if (n_soa == 3) {
                                n_soa = 1;
@@ -16290,8 +16287,7 @@ sync_secure_journal(dns_zone_t *zone, dns_zone_t *raw, dns_journal_t *journal,
 
                op = (n_soa == 1) ? DNS_DIFFOP_DEL : DNS_DIFFOP_ADD;
 
-               CHECK(dns_difftuple_create(diff->mctx, op, name, ttl, rdata,
-                                          &tuple));
+               dns_difftuple_create(diff->mctx, op, name, ttl, rdata, &tuple);
                dns_diff_appendminimal(diff, &tuple);
        }
        if (result == ISC_R_NOMORE) {
@@ -20343,8 +20339,8 @@ add_signing_records(dns_db_t *db, dns_rdatatype_t privatetype,
                                continue;
                        }
 
-                       CHECK(dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD,
-                                                  name, 0, &rdata, &newtuple));
+                       dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, name,
+                                            0, &rdata, &newtuple);
                        CHECK(do_one_tuple(&newtuple, db, ver, diff));
                        INSIST(newtuple == NULL);
                }
@@ -20356,8 +20352,8 @@ add_signing_records(dns_db_t *db, dns_rdatatype_t privatetype,
                buf[4] = 1;
                CHECK(rr_exists(db, ver, name, &rdata, &flag));
                if (flag) {
-                       CHECK(dns_difftuple_create(diff->mctx, DNS_DIFFOP_DEL,
-                                                  name, 0, &rdata, &newtuple));
+                       dns_difftuple_create(diff->mctx, DNS_DIFFOP_DEL, name,
+                                            0, &rdata, &newtuple);
                        CHECK(do_one_tuple(&newtuple, db, ver, diff));
                        INSIST(newtuple == NULL);
                }
@@ -21840,11 +21836,8 @@ update_ttl(dns_rdataset_t *rdataset, dns_name_t *name, dns_ttl_t ttl,
                dns_rdata_t rdata = DNS_RDATA_INIT;
 
                dns_rdataset_current(rdataset, &rdata);
-               result = dns_difftuple_create(diff->mctx, DNS_DIFFOP_DEL, name,
-                                             rdataset->ttl, &rdata, &tuple);
-               if (result != ISC_R_SUCCESS) {
-                       return (result);
-               }
+               dns_difftuple_create(diff->mctx, DNS_DIFFOP_DEL, name,
+                                    rdataset->ttl, &rdata, &tuple);
                dns_diff_appendminimal(diff, &tuple);
        }
        if (result != ISC_R_NOMORE) {
@@ -21861,11 +21854,8 @@ update_ttl(dns_rdataset_t *rdataset, dns_name_t *name, dns_ttl_t ttl,
                dns_rdata_t rdata = DNS_RDATA_INIT;
 
                dns_rdataset_current(rdataset, &rdata);
-               result = dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, name,
-                                             ttl, &rdata, &tuple);
-               if (result != ISC_R_SUCCESS) {
-                       return (result);
-               }
+               dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, name, ttl,
+                                    &rdata, &tuple);
                dns_diff_appendminimal(diff, &tuple);
        }
        if (result != ISC_R_NOMORE) {
@@ -23979,7 +23969,7 @@ setserial(void *arg) {
 
        CHECK(dns_db_createsoatuple(db, oldver, diff.mctx, DNS_DIFFOP_DEL,
                                    &oldtuple));
-       CHECK(dns_difftuple_copy(oldtuple, &newtuple));
+       dns_difftuple_copy(oldtuple, &newtuple);
        newtuple->op = DNS_DIFFOP_ADD;
 
        oldserial = dns_soa_getserial(&oldtuple->rdata);

diff --git a/lib/ns/update.c b/lib/ns/update.c
index e5e602983b9338e74fdae051a160a5bd7d850ded..1dc6cadd7a8c8a5acb79f5359e9195c9fc3e1e33 100644 (file)
--- a/lib/ns/update.c
+++ b/lib/ns/update.c
@@ -501,11 +501,8 @@ update_one_rr(dns_db_t *db, dns_dbversion_t *ver, dns_diff_t *diff,
              dns_diffop_t op, dns_name_t *name, dns_ttl_t ttl,
              dns_rdata_t *rdata) {
        dns_difftuple_t *tuple = NULL;
-       isc_result_t result;
-       result = dns_difftuple_create(diff->mctx, op, name, ttl, rdata, &tuple);
-       if (result != ISC_R_SUCCESS) {
-               return (result);
-       }
+
+       dns_difftuple_create(diff->mctx, op, name, ttl, rdata, &tuple);
        return (do_one_tuple(&tuple, db, ver, diff));
 }
 
@@ -1053,17 +1050,14 @@ ssu_checkrr(void *data, rr_t *rr) {
  * Append a tuple asserting the existence of the RR with
  * 'name' and 'rdata' to 'diff'.
  */
-static isc_result_t
+static void
 temp_append(dns_diff_t *diff, dns_name_t *name, dns_rdata_t *rdata) {
-       isc_result_t result;
        dns_difftuple_t *tuple = NULL;
 
        REQUIRE(DNS_DIFF_VALID(diff));
-       CHECK(dns_difftuple_create(diff->mctx, DNS_DIFFOP_EXISTS, name, 0,
-                                  rdata, &tuple));
+       dns_difftuple_create(diff->mctx, DNS_DIFFOP_EXISTS, name, 0, rdata,
+                            &tuple);
        ISC_LIST_APPEND(diff->tuples, tuple, link);
-failure:
-       return (result);
 }
 
 /*%
@@ -1207,10 +1201,7 @@ temp_check(isc_mem_t *mctx, dns_diff_t *temp, dns_db_t *db,
                        {
                                dns_rdata_t rdata = DNS_RDATA_INIT;
                                dns_rdataset_current(&rdataset, &rdata);
-                               result = temp_append(&d_rrs, name, &rdata);
-                               if (result != ISC_R_SUCCESS) {
-                                       goto failure;
-                               }
+                               temp_append(&d_rrs, name, &rdata);
                        }
                        if (result != ISC_R_NOMORE) {
                                goto failure;
@@ -1463,7 +1454,6 @@ delete_if(rr_predicate *predicate, dns_db_t *db, dns_dbversion_t *ver,
 
 static isc_result_t
 add_rr_prepare_action(void *data, rr_t *rr) {
-       isc_result_t result = ISC_R_SUCCESS;
        add_rr_prepare_ctx_t *ctx = data;
        dns_difftuple_t *tuple = NULL;
        bool equal, case_equal, ttl_equal;
@@ -1493,9 +1483,8 @@ add_rr_prepare_action(void *data, rr_t *rr) {
         * be deleted before the update RR is added.
         */
        if (replaces_p(ctx->update_rr, &rr->rdata)) {
-               CHECK(dns_difftuple_create(ctx->del_diff.mctx, DNS_DIFFOP_DEL,
-                                          ctx->oldname, rr->ttl, &rr->rdata,
-                                          &tuple));
+               dns_difftuple_create(ctx->del_diff.mctx, DNS_DIFFOP_DEL,
+                                    ctx->oldname, rr->ttl, &rr->rdata, &tuple);
                dns_diff_append(&ctx->del_diff, &tuple);
                return (ISC_R_SUCCESS);
        }
@@ -1505,19 +1494,18 @@ add_rr_prepare_action(void *data, rr_t *rr) {
         * its TTL and case must be adjusted.
         */
        if (!ttl_equal || !case_equal) {
-               CHECK(dns_difftuple_create(ctx->del_diff.mctx, DNS_DIFFOP_DEL,
-                                          ctx->oldname, rr->ttl, &rr->rdata,
-                                          &tuple));
+               dns_difftuple_create(ctx->del_diff.mctx, DNS_DIFFOP_DEL,
+                                    ctx->oldname, rr->ttl, &rr->rdata, &tuple);
                dns_diff_append(&ctx->del_diff, &tuple);
                if (!equal) {
-                       CHECK(dns_difftuple_create(
-                               ctx->add_diff.mctx, DNS_DIFFOP_ADD, ctx->name,
-                               ctx->update_rr_ttl, &rr->rdata, &tuple));
+                       dns_difftuple_create(ctx->add_diff.mctx, DNS_DIFFOP_ADD,
+                                            ctx->name, ctx->update_rr_ttl,
+                                            &rr->rdata, &tuple);
                        dns_diff_append(&ctx->add_diff, &tuple);
                }
        }
-failure:
-       return (result);
+
+       return (ISC_R_SUCCESS);
 }
 
 /**************************************************************************/
@@ -1574,7 +1562,7 @@ update_soa_serial(dns_db_t *db, dns_dbversion_t *ver, dns_diff_t *diff,
        isc_result_t result;
 
        CHECK(dns_db_createsoatuple(db, ver, mctx, DNS_DIFFOP_DEL, &deltuple));
-       CHECK(dns_difftuple_copy(deltuple, &addtuple));
+       dns_difftuple_copy(deltuple, &addtuple);
        addtuple->op = DNS_DIFFOP_ADD;
 
        serial = dns_soa_getserial(&addtuple->rdata);
@@ -2506,8 +2494,8 @@ add_nsec3param_records(ns_client_t *client, dns_zone_t *zone, dns_db_t *db,
                        }
                        op = (tuple->op == DNS_DIFFOP_DEL) ? DNS_DIFFOP_ADD
                                                           : DNS_DIFFOP_DEL;
-                       CHECK(dns_difftuple_create(diff->mctx, op, name, ttl,
-                                                  &tuple->rdata, &newtuple));
+                       dns_difftuple_create(diff->mctx, op, name, ttl,
+                                            &tuple->rdata, &newtuple);
                        CHECK(do_one_tuple(&newtuple, db, ver, diff));
                        ISC_LIST_UNLINK(temp_diff.tuples, tuple, link);
                        dns_diff_appendminimal(diff, &tuple);
@@ -2587,9 +2575,9 @@ add_nsec3param_records(ns_client_t *client, dns_zone_t *zone, dns_db_t *db,
                        CHECK(rr_exists(db, ver, name, &rdata, &flag));
 
                        if (!flag) {
-                               CHECK(dns_difftuple_create(
-                                       diff->mctx, DNS_DIFFOP_ADD, name, 0,
-                                       &rdata, &newtuple));
+                               dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD,
+                                                    name, 0, &rdata,
+                                                    &newtuple);
                                CHECK(do_one_tuple(&newtuple, db, ver, diff));
                        }
 
@@ -2602,9 +2590,9 @@ add_nsec3param_records(ns_client_t *client, dns_zone_t *zone, dns_db_t *db,
                        CHECK(rr_exists(db, ver, name, &rdata, &flag));
 
                        if (flag) {
-                               CHECK(dns_difftuple_create(
-                                       diff->mctx, DNS_DIFFOP_DEL, name, 0,
-                                       &rdata, &newtuple));
+                               dns_difftuple_create(diff->mctx, DNS_DIFFOP_DEL,
+                                                    name, 0, &rdata,
+                                                    &newtuple);
                                CHECK(do_one_tuple(&newtuple, db, ver, diff));
                        }
 
@@ -2613,9 +2601,8 @@ add_nsec3param_records(ns_client_t *client, dns_zone_t *zone, dns_db_t *db,
                         * temporary add record.
                         */
                        next = ISC_LIST_NEXT(tuple, link);
-                       CHECK(dns_difftuple_create(diff->mctx, DNS_DIFFOP_DEL,
-                                                  name, ttl, &tuple->rdata,
-                                                  &newtuple));
+                       dns_difftuple_create(diff->mctx, DNS_DIFFOP_DEL, name,
+                                            ttl, &tuple->rdata, &newtuple);
                        CHECK(do_one_tuple(&newtuple, db, ver, diff));
                        ISC_LIST_UNLINK(temp_diff.tuples, tuple, link);
                        dns_diff_appendminimal(diff, &tuple);
@@ -2646,12 +2633,12 @@ add_nsec3param_records(ns_client_t *client, dns_zone_t *zone, dns_db_t *db,
                }
 
                if (!flag) {
-                       CHECK(dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD,
-                                                  name, 0, &rdata, &newtuple));
+                       dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, name,
+                                            0, &rdata, &newtuple);
                        CHECK(do_one_tuple(&newtuple, db, ver, diff));
                }
-               CHECK(dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, name,
-                                          ttl, &tuple->rdata, &newtuple));
+               dns_difftuple_create(diff->mctx, DNS_DIFFOP_ADD, name, ttl,
+                                    &tuple->rdata, &newtuple);
                CHECK(do_one_tuple(&newtuple, db, ver, diff));
                ISC_LIST_UNLINK(temp_diff.tuples, tuple, link);
                dns_diff_appendminimal(diff, &tuple);
@@ -2712,8 +2699,8 @@ rollback_private(dns_db_t *db, dns_rdatatype_t privatetype,
        while ((tuple = ISC_LIST_HEAD(temp_diff.tuples)) != NULL) {
                op = (tuple->op == DNS_DIFFOP_DEL) ? DNS_DIFFOP_ADD
                                                   : DNS_DIFFOP_DEL;
-               CHECK(dns_difftuple_create(mctx, op, name, tuple->ttl,
-                                          &tuple->rdata, &newtuple));
+               dns_difftuple_create(mctx, op, name, tuple->ttl, &tuple->rdata,
+                                    &newtuple);
                CHECK(do_one_tuple(&newtuple, db, ver, &temp_diff));
        }
        result = ISC_R_SUCCESS;
@@ -2871,13 +2858,7 @@ update_action(void *arg) {
                        }
                } else if (update_class == zoneclass) {
                        /* "temp<rr.name, rr.type> += rr;" */
-                       result = temp_append(&temp, name, &rdata);
-                       if (result != ISC_R_SUCCESS) {
-                               UNEXPECTED_ERROR(
-                                       "temp entry creation failed: %s",
-                                       isc_result_totext(result));
-                               FAIL(ISC_R_UNEXPECTED);
-                       }
+                       temp_append(&temp, name, &rdata);
                } else {
                        PREREQFAILC(DNS_R_FORMERR, "malformed prerequisite");
                }

diff --git a/tests/libtest/dns.c b/tests/libtest/dns.c
index 8dd1bbc5e53ba9b5d1a03465252ea45dec211710..ba5aa995c39993fe6c88837f3ba2d71d8803ed0a 100644 (file)
--- a/tests/libtest/dns.c
+++ b/tests/libtest/dns.c
@@ -487,11 +487,8 @@ dns_test_difffromchanges(dns_diff_t *diff, const zonechange_t *changes,
                 * Create a diff tuple for the parsed change and append it to
                 * the diff.
                 */
-               result = dns_difftuple_create(mctx, changes[i].op, name,
-                                             changes[i].ttl, &rdata, &tuple);
-               if (result != ISC_R_SUCCESS) {
-                       break;
-               }
+               dns_difftuple_create(mctx, changes[i].op, name, changes[i].ttl,
+                                    &rdata, &tuple);
                dns_diff_append(diff, &tuple);
        }