From: Evan Hunt Date: Fri, 12 Jul 2024 00:00:38 +0000 (-0700) Subject: dns_difftuple_create() cannot fail X-Git-Tag: alessio/regression/a26055f03e~1^2 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=a68a77ca8684b07b791c9192062e0826e9d19de6;p=thirdparty%2Fbind9.git 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 b38de8e942f..fed31e8139a 100644 --- 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 364fa670ee6..6e232e29024 100644 --- 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 efefbaa2a0b..b25c77f7c51 100644 --- 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 eaf7ef6f11c..ffb033b0083 100644 --- 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 3bda5644d6e..5b5cc1f0c4a 100644 --- 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 604766d56f9..0d7b4a7904b 100644 --- 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 acecc41233a..e92557e0025 100644 --- 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 a6b8f2adf4a..0deef07b4b2 100644 --- 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 523b59a5a65..f321924728a 100644 --- 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 0bf4b6b865a..8336f274855 100644 --- 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 e5e602983b9..1dc6cadd7a8 100644 --- 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;" */ - 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 8dd1bbc5e53..ba5aa995c39 100644 --- 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); }