From 4af46a8574d764bf9fdf75f2096ec4e3cd8b2c51 Mon Sep 17 00:00:00 2001 From: Matthijs Mekking Date: Wed, 5 Feb 2020 11:40:42 +0100 Subject: [PATCH] rdata: delay assignment until after REQUIRE --- lib/dns/rdata/any_255/tsig_250.c | 20 +++++++----- lib/dns/rdata/ch_3/a_1.c | 22 +++++++++----- lib/dns/rdata/generic/afsdb_18.c | 25 +++++++++------ lib/dns/rdata/generic/amtrelay_260.c | 25 +++++++++------ lib/dns/rdata/generic/avc_258.c | 12 ++++---- lib/dns/rdata/generic/caa_257.c | 30 +++++++++++------- lib/dns/rdata/generic/cdnskey_60.c | 13 ++++---- lib/dns/rdata/generic/cds_59.c | 15 ++++++--- lib/dns/rdata/generic/cert_37.c | 25 +++++++++------ lib/dns/rdata/generic/cname_5.c | 22 +++++++++----- lib/dns/rdata/generic/csync_62.c | 28 +++++++++++------ lib/dns/rdata/generic/dlv_32769.c | 15 ++++++--- lib/dns/rdata/generic/dname_39.c | 25 +++++++++------ lib/dns/rdata/generic/dnskey_48.c | 13 ++++---- lib/dns/rdata/generic/doa_259.c | 26 ++++++++++------ lib/dns/rdata/generic/ds_43.c | 36 +++++++++++++--------- lib/dns/rdata/generic/eui48_108.c | 23 ++++++++------ lib/dns/rdata/generic/eui64_109.c | 23 ++++++++------ lib/dns/rdata/generic/gpos_27.c | 25 +++++++++------ lib/dns/rdata/generic/hinfo_13.c | 22 +++++++++----- lib/dns/rdata/generic/hip_55.c | 36 ++++++++++++++-------- lib/dns/rdata/generic/ipseckey_45.c | 25 +++++++++------ lib/dns/rdata/generic/isdn_20.c | 22 +++++++++----- lib/dns/rdata/generic/key_25.c | 41 ++++++++++++++----------- lib/dns/rdata/generic/keydata_65533.c | 27 ++++++++++------ lib/dns/rdata/generic/l32_105.c | 23 ++++++++------ lib/dns/rdata/generic/l64_106.c | 23 ++++++++------ lib/dns/rdata/generic/loc_29.c | 25 +++++++++------ lib/dns/rdata/generic/lp_107.c | 24 +++++++++------ lib/dns/rdata/generic/mb_7.c | 22 +++++++++----- lib/dns/rdata/generic/md_3.c | 24 +++++++++------ lib/dns/rdata/generic/mf_4.c | 24 +++++++++------ lib/dns/rdata/generic/mg_8.c | 24 +++++++++------ lib/dns/rdata/generic/minfo_14.c | 25 +++++++++------ lib/dns/rdata/generic/mr_9.c | 24 +++++++++------ lib/dns/rdata/generic/mx_15.c | 24 +++++++++------ lib/dns/rdata/generic/naptr_35.c | 34 +++++++++++++-------- lib/dns/rdata/generic/nid_104.c | 23 ++++++++------ lib/dns/rdata/generic/ninfo_56.c | 13 ++++---- lib/dns/rdata/generic/ns_2.c | 22 +++++++++----- lib/dns/rdata/generic/nsec3_50.c | 30 +++++++++++------- lib/dns/rdata/generic/nsec3param_51.c | 25 +++++++++------ lib/dns/rdata/generic/nsec_47.c | 28 +++++++++++------ lib/dns/rdata/generic/null_10.c | 28 +++++++++++------ lib/dns/rdata/generic/nxt_30.c | 29 ++++++++++++------ lib/dns/rdata/generic/openpgpkey_61.c | 28 +++++++++++------ lib/dns/rdata/generic/opt_41.c | 28 +++++++++++------ lib/dns/rdata/generic/ptr_12.c | 25 +++++++++------ lib/dns/rdata/generic/rkey_57.c | 13 ++++---- lib/dns/rdata/generic/rp_17.c | 24 +++++++++------ lib/dns/rdata/generic/rrsig_46.c | 28 +++++++++++------ lib/dns/rdata/generic/rt_21.c | 24 +++++++++------ lib/dns/rdata/generic/sig_24.c | 28 +++++++++++------ lib/dns/rdata/generic/sink_40.c | 25 +++++++++------ lib/dns/rdata/generic/smimea_53.c | 13 ++++---- lib/dns/rdata/generic/soa_6.c | 25 +++++++++------ lib/dns/rdata/generic/spf_99.c | 13 ++++---- lib/dns/rdata/generic/sshfp_44.c | 25 +++++++++------ lib/dns/rdata/generic/ta_32768.c | 14 ++++++--- lib/dns/rdata/generic/talink_58.c | 25 +++++++++------ lib/dns/rdata/generic/tkey_249.c | 22 +++++++++----- lib/dns/rdata/generic/tlsa_52.c | 41 ++++++++++++++----------- lib/dns/rdata/generic/txt_16.c | 44 ++++++++++++++++----------- lib/dns/rdata/generic/uri_256.c | 28 +++++++++++------ lib/dns/rdata/generic/x25_19.c | 28 +++++++++++------ lib/dns/rdata/generic/zonemd_63.c | 25 +++++++++------ lib/dns/rdata/hs_4/a_1.c | 16 ++++++---- lib/dns/rdata/in_1/a6_38.c | 28 +++++++++++------ lib/dns/rdata/in_1/a_1.c | 27 ++++++++++------ lib/dns/rdata/in_1/aaaa_28.c | 28 +++++++++++------ lib/dns/rdata/in_1/apl_42.c | 31 ++++++++++++------- lib/dns/rdata/in_1/atma_34.c | 31 ++++++++++++------- lib/dns/rdata/in_1/dhcid_49.c | 30 +++++++++++------- lib/dns/rdata/in_1/eid_31.c | 31 ++++++++++++------- lib/dns/rdata/in_1/kx_36.c | 28 +++++++++++------ lib/dns/rdata/in_1/nimloc_32.c | 31 ++++++++++++------- lib/dns/rdata/in_1/nsap-ptr_23.c | 28 +++++++++++------ lib/dns/rdata/in_1/nsap_22.c | 31 ++++++++++++------- lib/dns/rdata/in_1/px_26.c | 28 +++++++++++------ lib/dns/rdata/in_1/srv_33.c | 28 +++++++++++------ lib/dns/rdata/in_1/wks_11.c | 33 ++++++++++++-------- 81 files changed, 1280 insertions(+), 765 deletions(-) diff --git a/lib/dns/rdata/any_255/tsig_250.c b/lib/dns/rdata/any_255/tsig_250.c index c83b6c3fe41..e68cc40fcc9 100644 --- a/lib/dns/rdata/any_255/tsig_250.c +++ b/lib/dns/rdata/any_255/tsig_250.c @@ -353,14 +353,16 @@ compare_any_tsig(ARGS_COMPARE) { static inline isc_result_t fromstruct_any_tsig(ARGS_FROMSTRUCT) { - dns_rdata_any_tsig_t *tsig = source; + dns_rdata_any_tsig_t *tsig; isc_region_t tr; REQUIRE(type == dns_rdatatype_tsig); REQUIRE(rdclass == dns_rdataclass_any); - REQUIRE(tsig != NULL); - REQUIRE(tsig->common.rdclass == rdclass); - REQUIRE(tsig->common.rdtype == type); + REQUIRE(((dns_rdata_any_tsig_t *)source) != NULL); + REQUIRE(((dns_rdata_any_tsig_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_any_tsig_t *)source)->common.rdtype == type); + + tsig = source; UNUSED(type); UNUSED(rdclass); @@ -521,11 +523,13 @@ tostruct_any_tsig(ARGS_TOSTRUCT) { static inline void freestruct_any_tsig(ARGS_FREESTRUCT) { - dns_rdata_any_tsig_t *tsig = (dns_rdata_any_tsig_t *) source; + dns_rdata_any_tsig_t *tsig; + + REQUIRE(((dns_rdata_any_tsig_t *)source) != NULL); + REQUIRE(((dns_rdata_any_tsig_t *)source)->common.rdtype == dns_rdatatype_tsig); + REQUIRE(((dns_rdata_any_tsig_t *)source)->common.rdclass == dns_rdataclass_any); - REQUIRE(tsig != NULL); - REQUIRE(tsig->common.rdtype == dns_rdatatype_tsig); - REQUIRE(tsig->common.rdclass == dns_rdataclass_any); + tsig = (dns_rdata_any_tsig_t *) source; if (tsig->mctx == NULL) return; diff --git a/lib/dns/rdata/ch_3/a_1.c b/lib/dns/rdata/ch_3/a_1.c index be1b489ef43..a1a32d8b13f 100644 --- a/lib/dns/rdata/ch_3/a_1.c +++ b/lib/dns/rdata/ch_3/a_1.c @@ -187,13 +187,15 @@ compare_ch_a(ARGS_COMPARE) { static inline isc_result_t fromstruct_ch_a(ARGS_FROMSTRUCT) { - dns_rdata_ch_a_t *a = source; + dns_rdata_ch_a_t *a; isc_region_t region; REQUIRE(type == dns_rdatatype_a); - REQUIRE(a != NULL); - REQUIRE(a->common.rdtype == type); - REQUIRE(a->common.rdclass == rdclass); + REQUIRE(((dns_rdata_ch_a_t *)source) != NULL); + REQUIRE(((dns_rdata_ch_a_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_ch_a_t *)source)->common.rdclass == rdclass); + + a = source; UNUSED(type); UNUSED(rdclass); @@ -206,7 +208,7 @@ fromstruct_ch_a(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_ch_a(ARGS_TOSTRUCT) { - dns_rdata_ch_a_t *a = target; + dns_rdata_ch_a_t *a; isc_region_t region; dns_name_t name; @@ -214,6 +216,8 @@ tostruct_ch_a(ARGS_TOSTRUCT) { REQUIRE(rdata->rdclass == dns_rdataclass_ch); REQUIRE(rdata->length != 0); + a = target; + a->common.rdclass = rdata->rdclass; a->common.rdtype = rdata->type; ISC_LINK_INIT(&a->common, link); @@ -233,10 +237,12 @@ tostruct_ch_a(ARGS_TOSTRUCT) { static inline void freestruct_ch_a(ARGS_FREESTRUCT) { - dns_rdata_ch_a_t *a = source; + dns_rdata_ch_a_t *a; + + REQUIRE(((dns_rdata_ch_a_t *)source) != NULL); + REQUIRE(((dns_rdata_ch_a_t *)source)->common.rdtype == dns_rdatatype_a); - REQUIRE(a != NULL); - REQUIRE(a->common.rdtype == dns_rdatatype_a); + a = source; if (a->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/afsdb_18.c b/lib/dns/rdata/generic/afsdb_18.c index 2c924b9f8d9..44786c9e75f 100644 --- a/lib/dns/rdata/generic/afsdb_18.c +++ b/lib/dns/rdata/generic/afsdb_18.c @@ -170,13 +170,15 @@ compare_afsdb(ARGS_COMPARE) { static inline isc_result_t fromstruct_afsdb(ARGS_FROMSTRUCT) { - dns_rdata_afsdb_t *afsdb = source; + dns_rdata_afsdb_t *afsdb; isc_region_t region; REQUIRE(type == dns_rdatatype_afsdb); - REQUIRE(afsdb != NULL); - REQUIRE(afsdb->common.rdclass == rdclass); - REQUIRE(afsdb->common.rdtype == type); + REQUIRE(((dns_rdata_afsdb_t *)source) != NULL); + REQUIRE(((dns_rdata_afsdb_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_afsdb_t *)source)->common.rdtype == type); + + afsdb = source; UNUSED(type); UNUSED(rdclass); @@ -189,13 +191,15 @@ fromstruct_afsdb(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_afsdb(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_afsdb_t *afsdb = target; + dns_rdata_afsdb_t *afsdb; dns_name_t name; + REQUIRE(((dns_rdata_afsdb_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_afsdb); - REQUIRE(afsdb != NULL); REQUIRE(rdata->length != 0); + afsdb = target; + afsdb->common.rdclass = rdata->rdclass; afsdb->common.rdtype = rdata->type; ISC_LINK_INIT(&afsdb->common, link); @@ -217,10 +221,13 @@ tostruct_afsdb(ARGS_TOSTRUCT) { static inline void freestruct_afsdb(ARGS_FREESTRUCT) { - dns_rdata_afsdb_t *afsdb = source; + dns_rdata_afsdb_t *afsdb; + + REQUIRE(((dns_rdata_afsdb_t *)source) != NULL); + REQUIRE(((dns_rdata_afsdb_t *)source)->common.rdtype == + dns_rdatatype_afsdb); - REQUIRE(afsdb != NULL); - REQUIRE(afsdb->common.rdtype == dns_rdatatype_afsdb); + afsdb = source; if (afsdb->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/amtrelay_260.c b/lib/dns/rdata/generic/amtrelay_260.c index ca266383a30..d0e00ba59ff 100644 --- a/lib/dns/rdata/generic/amtrelay_260.c +++ b/lib/dns/rdata/generic/amtrelay_260.c @@ -264,14 +264,16 @@ compare_amtrelay(ARGS_COMPARE) { static inline isc_result_t fromstruct_amtrelay(ARGS_FROMSTRUCT) { - dns_rdata_amtrelay_t *amtrelay = source; + dns_rdata_amtrelay_t *amtrelay; isc_region_t region; uint32_t n; REQUIRE(type == dns_rdatatype_amtrelay); - REQUIRE(amtrelay != NULL); - REQUIRE(amtrelay->common.rdtype == type); - REQUIRE(amtrelay->common.rdclass == rdclass); + REQUIRE(((dns_rdata_amtrelay_t *)source) != NULL); + REQUIRE(((dns_rdata_amtrelay_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_amtrelay_t *)source)->common.rdclass == rdclass); + + amtrelay = source; UNUSED(type); UNUSED(rdclass); @@ -305,14 +307,16 @@ fromstruct_amtrelay(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_amtrelay(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_amtrelay_t *amtrelay = target; + dns_rdata_amtrelay_t *amtrelay; dns_name_t name; uint32_t n; + REQUIRE(((dns_rdata_amtrelay_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_amtrelay); - REQUIRE(amtrelay != NULL); REQUIRE(rdata->length >= 2); + amtrelay = target; + amtrelay->common.rdclass = rdata->rdclass; amtrelay->common.rdtype = rdata->type; ISC_LINK_INIT(&amtrelay->common, link); @@ -368,10 +372,13 @@ tostruct_amtrelay(ARGS_TOSTRUCT) { static inline void freestruct_amtrelay(ARGS_FREESTRUCT) { - dns_rdata_amtrelay_t *amtrelay = source; + dns_rdata_amtrelay_t *amtrelay; + + REQUIRE(((dns_rdata_amtrelay_t *)source) != NULL); + REQUIRE(((dns_rdata_amtrelay_t *)source)->common.rdtype == + dns_rdatatype_amtrelay); - REQUIRE(amtrelay != NULL); - REQUIRE(amtrelay->common.rdtype == dns_rdatatype_amtrelay); + amtrelay = source; if (amtrelay->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/avc_258.c b/lib/dns/rdata/generic/avc_258.c index e8efa377d70..5aef89849cc 100644 --- a/lib/dns/rdata/generic/avc_258.c +++ b/lib/dns/rdata/generic/avc_258.c @@ -87,10 +87,12 @@ fromstruct_avc(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_avc(ARGS_TOSTRUCT) { - dns_rdata_avc_t *avc = target; + dns_rdata_avc_t *avc; + REQUIRE(((dns_rdata_avc_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_avc); - REQUIRE(avc != NULL); + + avc = target; avc->common.rdclass = rdata->rdclass; avc->common.rdtype = rdata->type; @@ -101,10 +103,8 @@ tostruct_avc(ARGS_TOSTRUCT) { static inline void freestruct_avc(ARGS_FREESTRUCT) { - dns_rdata_avc_t *avc = source; - - REQUIRE(avc != NULL); - REQUIRE(avc->common.rdtype == dns_rdatatype_avc); + REQUIRE(((dns_rdata_avc_t *)source) != NULL); + REQUIRE(((dns_rdata_avc_t *)source)->common.rdtype == dns_rdatatype_avc); generic_freestruct_txt(source); } diff --git a/lib/dns/rdata/generic/caa_257.c b/lib/dns/rdata/generic/caa_257.c index 8dd75c04dd9..ef90bd3763a 100644 --- a/lib/dns/rdata/generic/caa_257.c +++ b/lib/dns/rdata/generic/caa_257.c @@ -191,16 +191,19 @@ compare_caa(ARGS_COMPARE) { static inline isc_result_t fromstruct_caa(ARGS_FROMSTRUCT) { - dns_rdata_caa_t *caa = source; + dns_rdata_caa_t *caa; isc_region_t region; unsigned int i; REQUIRE(type == dns_rdatatype_caa); - REQUIRE(caa != NULL); - REQUIRE(caa->common.rdtype == type); - REQUIRE(caa->common.rdclass == rdclass); - REQUIRE(caa->tag != NULL && caa->tag_len != 0); - REQUIRE(caa->value != NULL); + REQUIRE(((dns_rdata_caa_t *)source) != NULL); + REQUIRE(((dns_rdata_caa_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_caa_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_caa_t *)source)->tag != NULL); + REQUIRE(((dns_rdata_caa_t *)source)->tag_len != 0); + REQUIRE(((dns_rdata_caa_t *)source)->value != NULL); + + caa = source; UNUSED(type); UNUSED(rdclass); @@ -235,14 +238,16 @@ fromstruct_caa(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_caa(ARGS_TOSTRUCT) { - dns_rdata_caa_t *caa = target; + dns_rdata_caa_t *caa; isc_region_t sr; + REQUIRE(((dns_rdata_caa_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_caa); - REQUIRE(caa != NULL); REQUIRE(rdata->length >= 3U); REQUIRE(rdata->data != NULL); + caa = target; + caa->common.rdclass = rdata->rdclass; caa->common.rdtype = rdata->type; ISC_LINK_INIT(&caa->common, link); @@ -289,10 +294,13 @@ tostruct_caa(ARGS_TOSTRUCT) { static inline void freestruct_caa(ARGS_FREESTRUCT) { - dns_rdata_caa_t *caa = (dns_rdata_caa_t *) source; + dns_rdata_caa_t *caa; + + REQUIRE(((dns_rdata_caa_t *)source) != NULL); + REQUIRE(((dns_rdata_caa_t *)source)->common.rdtype == + dns_rdatatype_caa); - REQUIRE(caa != NULL); - REQUIRE(caa->common.rdtype == dns_rdatatype_caa); + caa = source; if (caa->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/cdnskey_60.c b/lib/dns/rdata/generic/cdnskey_60.c index afcdbc2265d..14fb4219432 100644 --- a/lib/dns/rdata/generic/cdnskey_60.c +++ b/lib/dns/rdata/generic/cdnskey_60.c @@ -86,12 +86,14 @@ fromstruct_cdnskey(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_cdnskey(ARGS_TOSTRUCT) { - dns_rdata_cdnskey_t *dnskey = target; + dns_rdata_cdnskey_t *dnskey; - REQUIRE(dnskey != NULL); + REQUIRE(((dns_rdata_cdnskey_t *)target) != NULL); REQUIRE(rdata != NULL); REQUIRE(rdata->type == dns_rdatatype_cdnskey); + dnskey = target; + dnskey->common.rdclass = rdata->rdclass; dnskey->common.rdtype = rdata->type; ISC_LINK_INIT(&dnskey->common, link); @@ -101,10 +103,9 @@ tostruct_cdnskey(ARGS_TOSTRUCT) { static inline void freestruct_cdnskey(ARGS_FREESTRUCT) { - dns_rdata_cdnskey_t *dnskey = (dns_rdata_cdnskey_t *) source; - - REQUIRE(dnskey != NULL); - REQUIRE(dnskey->common.rdtype == dns_rdatatype_cdnskey); + REQUIRE(((dns_rdata_cdnskey_t *)source) != NULL); + REQUIRE(((dns_rdata_cdnskey_t *)source)->common.rdtype == + dns_rdatatype_cdnskey); generic_freestruct_key(source); } diff --git a/lib/dns/rdata/generic/cds_59.c b/lib/dns/rdata/generic/cds_59.c index f4f9a944115..347c5b0aa2b 100644 --- a/lib/dns/rdata/generic/cds_59.c +++ b/lib/dns/rdata/generic/cds_59.c @@ -88,12 +88,14 @@ fromstruct_cds(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_cds(ARGS_TOSTRUCT) { - dns_rdata_cds_t *cds = target; + dns_rdata_cds_t *cds; + REQUIRE(((dns_rdata_cds_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_cds); - REQUIRE(cds != NULL); REQUIRE(rdata->length != 0); + cds = target; + /* * Checked by generic_tostruct_ds(). */ @@ -106,10 +108,13 @@ tostruct_cds(ARGS_TOSTRUCT) { static inline void freestruct_cds(ARGS_FREESTRUCT) { - dns_rdata_cds_t *cds = source; + dns_rdata_cds_t *cds; + + REQUIRE(((dns_rdata_cds_t *)source) != NULL); + REQUIRE(((dns_rdata_cds_t *)source)->common.rdtype == + dns_rdatatype_cds); - REQUIRE(cds != NULL); - REQUIRE(cds->common.rdtype == dns_rdatatype_cds); + cds = source; if (cds->mctx == NULL) { return; diff --git a/lib/dns/rdata/generic/cert_37.c b/lib/dns/rdata/generic/cert_37.c index 4b29cabdea2..16c859809fc 100644 --- a/lib/dns/rdata/generic/cert_37.c +++ b/lib/dns/rdata/generic/cert_37.c @@ -159,12 +159,14 @@ compare_cert(ARGS_COMPARE) { static inline isc_result_t fromstruct_cert(ARGS_FROMSTRUCT) { - dns_rdata_cert_t *cert = source; + dns_rdata_cert_t *cert; REQUIRE(type == dns_rdatatype_cert); - REQUIRE(cert != NULL); - REQUIRE(cert->common.rdtype == type); - REQUIRE(cert->common.rdclass == rdclass); + REQUIRE(((dns_rdata_cert_t *)source) != NULL); + REQUIRE(((dns_rdata_cert_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_cert_t *)source)->common.rdclass == rdclass); + + cert = source; UNUSED(type); UNUSED(rdclass); @@ -178,13 +180,15 @@ fromstruct_cert(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_cert(ARGS_TOSTRUCT) { - dns_rdata_cert_t *cert = target; + dns_rdata_cert_t *cert; isc_region_t region; + REQUIRE(((dns_rdata_cert_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_cert); - REQUIRE(cert != NULL); REQUIRE(rdata->length != 0); + cert = target; + cert->common.rdclass = rdata->rdclass; cert->common.rdtype = rdata->type; ISC_LINK_INIT(&cert->common, link); @@ -209,10 +213,13 @@ tostruct_cert(ARGS_TOSTRUCT) { static inline void freestruct_cert(ARGS_FREESTRUCT) { - dns_rdata_cert_t *cert = source; + dns_rdata_cert_t *cert; + + REQUIRE(((dns_rdata_cert_t *)source) != NULL); + REQUIRE(((dns_rdata_cert_t *)source)->common.rdtype == + dns_rdatatype_cert); - REQUIRE(cert != NULL); - REQUIRE(cert->common.rdtype == dns_rdatatype_cert); + cert = source; if (cert->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/cname_5.c b/lib/dns/rdata/generic/cname_5.c index 1c40bcd6da5..699ca557edd 100644 --- a/lib/dns/rdata/generic/cname_5.c +++ b/lib/dns/rdata/generic/cname_5.c @@ -119,13 +119,15 @@ compare_cname(ARGS_COMPARE) { static inline isc_result_t fromstruct_cname(ARGS_FROMSTRUCT) { - dns_rdata_cname_t *cname = source; + dns_rdata_cname_t *cname; isc_region_t region; REQUIRE(type == dns_rdatatype_cname); - REQUIRE(cname != NULL); - REQUIRE(cname->common.rdtype == type); - REQUIRE(cname->common.rdclass == rdclass); + REQUIRE(((dns_rdata_cname_t *)source) != NULL); + REQUIRE(((dns_rdata_cname_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_cname_t *)source)->common.rdclass == rdclass); + + cname = source; UNUSED(type); UNUSED(rdclass); @@ -137,13 +139,15 @@ fromstruct_cname(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_cname(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_cname_t *cname = target; + dns_rdata_cname_t *cname; dns_name_t name; + REQUIRE(((dns_rdata_cname_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_cname); - REQUIRE(cname != NULL); REQUIRE(rdata->length != 0); + cname = target; + cname->common.rdclass = rdata->rdclass; cname->common.rdtype = rdata->type; ISC_LINK_INIT(&cname->common, link); @@ -159,9 +163,11 @@ tostruct_cname(ARGS_TOSTRUCT) { static inline void freestruct_cname(ARGS_FREESTRUCT) { - dns_rdata_cname_t *cname = source; + dns_rdata_cname_t *cname; + + REQUIRE(((dns_rdata_cname_t *)source) != NULL); - REQUIRE(cname != NULL); + cname = source; if (cname->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/csync_62.c b/lib/dns/rdata/generic/csync_62.c index 481916d3d6f..9cfcb35f101 100644 --- a/lib/dns/rdata/generic/csync_62.c +++ b/lib/dns/rdata/generic/csync_62.c @@ -136,14 +136,17 @@ compare_csync(ARGS_COMPARE) { static inline isc_result_t fromstruct_csync(ARGS_FROMSTRUCT) { - dns_rdata_csync_t *csync = source; + dns_rdata_csync_t *csync; isc_region_t region; REQUIRE(type == dns_rdatatype_csync); - REQUIRE(csync != NULL); - REQUIRE(csync->common.rdtype == type); - REQUIRE(csync->common.rdclass == rdclass); - REQUIRE(csync->typebits != NULL || csync->len == 0); + REQUIRE(((dns_rdata_csync_t *)source) != NULL); + REQUIRE(((dns_rdata_csync_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_csync_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_csync_t *)source)->typebits != NULL || + ((dns_rdata_csync_t *)source)->len == 0); + + csync = source; UNUSED(type); UNUSED(rdclass); @@ -160,12 +163,14 @@ fromstruct_csync(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_csync(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_csync_t *csync = target; + dns_rdata_csync_t *csync; + REQUIRE(((dns_rdata_csync_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_csync); - REQUIRE(csync != NULL); REQUIRE(rdata->length != 0); + csync = target; + csync->common.rdclass = rdata->rdclass; csync->common.rdtype = rdata->type; ISC_LINK_INIT(&csync->common, link); @@ -192,10 +197,13 @@ tostruct_csync(ARGS_TOSTRUCT) { static inline void freestruct_csync(ARGS_FREESTRUCT) { - dns_rdata_csync_t *csync = source; + dns_rdata_csync_t *csync; + + REQUIRE(((dns_rdata_csync_t *)source) != NULL); + REQUIRE(((dns_rdata_csync_t *)source)->common.rdtype == + dns_rdatatype_csync); - REQUIRE(csync != NULL); - REQUIRE(csync->common.rdtype == dns_rdatatype_csync); + csync = source; if (csync->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/dlv_32769.c b/lib/dns/rdata/generic/dlv_32769.c index 89a46d98f7e..90e3b6c225c 100644 --- a/lib/dns/rdata/generic/dlv_32769.c +++ b/lib/dns/rdata/generic/dlv_32769.c @@ -89,10 +89,12 @@ fromstruct_dlv(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_dlv(ARGS_TOSTRUCT) { - dns_rdata_dlv_t *dlv = target; + dns_rdata_dlv_t *dlv; + REQUIRE(((dns_rdata_dlv_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_dlv); - REQUIRE(dlv != NULL); + + dlv = target; dlv->common.rdclass = rdata->rdclass; dlv->common.rdtype = rdata->type; @@ -103,10 +105,13 @@ tostruct_dlv(ARGS_TOSTRUCT) { static inline void freestruct_dlv(ARGS_FREESTRUCT) { - dns_rdata_dlv_t *dlv = source; + dns_rdata_dlv_t *dlv; + + REQUIRE(((dns_rdata_dlv_t *)source) != NULL); + REQUIRE(((dns_rdata_dlv_t *)source)->common.rdtype == + dns_rdatatype_dlv); - REQUIRE(dlv != NULL); - REQUIRE(dlv->common.rdtype == dns_rdatatype_dlv); + dlv = source; if (dlv->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/dname_39.c b/lib/dns/rdata/generic/dname_39.c index cebd8c7e46e..93b71855bb0 100644 --- a/lib/dns/rdata/generic/dname_39.c +++ b/lib/dns/rdata/generic/dname_39.c @@ -119,13 +119,15 @@ compare_dname(ARGS_COMPARE) { static inline isc_result_t fromstruct_dname(ARGS_FROMSTRUCT) { - dns_rdata_dname_t *dname = source; + dns_rdata_dname_t *dname; isc_region_t region; REQUIRE(type == dns_rdatatype_dname); - REQUIRE(dname != NULL); - REQUIRE(dname->common.rdtype == type); - REQUIRE(dname->common.rdclass == rdclass); + REQUIRE(((dns_rdata_dname_t *)source) != NULL); + REQUIRE(((dns_rdata_dname_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_dname_t *)source)->common.rdclass == rdclass); + + dname = source; UNUSED(type); UNUSED(rdclass); @@ -137,13 +139,15 @@ fromstruct_dname(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_dname(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_dname_t *dname = target; + dns_rdata_dname_t *dname; dns_name_t name; + REQUIRE(((dns_rdata_dname_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_dname); - REQUIRE(dname != NULL); REQUIRE(rdata->length != 0); + dname = target; + dname->common.rdclass = rdata->rdclass; dname->common.rdtype = rdata->type; ISC_LINK_INIT(&dname->common, link); @@ -159,10 +163,13 @@ tostruct_dname(ARGS_TOSTRUCT) { static inline void freestruct_dname(ARGS_FREESTRUCT) { - dns_rdata_dname_t *dname = source; + dns_rdata_dname_t *dname; + + REQUIRE(((dns_rdata_dname_t *)source) != NULL); + REQUIRE(((dns_rdata_dname_t *)source)->common.rdtype == + dns_rdatatype_dname); - REQUIRE(dname != NULL); - REQUIRE(dname->common.rdtype == dns_rdatatype_dname); + dname = source; if (dname->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/dnskey_48.c b/lib/dns/rdata/generic/dnskey_48.c index f20a8f6110d..8d138e80754 100644 --- a/lib/dns/rdata/generic/dnskey_48.c +++ b/lib/dns/rdata/generic/dnskey_48.c @@ -87,12 +87,14 @@ fromstruct_dnskey(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_dnskey(ARGS_TOSTRUCT) { - dns_rdata_dnskey_t *dnskey = target; + dns_rdata_dnskey_t *dnskey; - REQUIRE(dnskey != NULL); + REQUIRE(((dns_rdata_dnskey_t *)target) != NULL); REQUIRE(rdata != NULL); REQUIRE(rdata->type == dns_rdatatype_dnskey); + dnskey = target; + dnskey->common.rdclass = rdata->rdclass; dnskey->common.rdtype = rdata->type; ISC_LINK_INIT(&dnskey->common, link); @@ -102,10 +104,9 @@ tostruct_dnskey(ARGS_TOSTRUCT) { static inline void freestruct_dnskey(ARGS_FREESTRUCT) { - dns_rdata_dnskey_t *dnskey = (dns_rdata_dnskey_t *) source; - - REQUIRE(dnskey != NULL); - REQUIRE(dnskey->common.rdtype == dns_rdatatype_dnskey); + REQUIRE(((dns_rdata_dnskey_t *)source) != NULL); + REQUIRE(((dns_rdata_dnskey_t *)source)->common.rdtype == + dns_rdatatype_dnskey); generic_freestruct_key(source); } diff --git a/lib/dns/rdata/generic/doa_259.c b/lib/dns/rdata/generic/doa_259.c index 8597e5a5641..9734cac3bd6 100644 --- a/lib/dns/rdata/generic/doa_259.c +++ b/lib/dns/rdata/generic/doa_259.c @@ -188,12 +188,15 @@ compare_doa(ARGS_COMPARE) { static inline isc_result_t fromstruct_doa(ARGS_FROMSTRUCT) { - dns_rdata_doa_t *doa = source; + dns_rdata_doa_t *doa; REQUIRE(type == dns_rdatatype_doa); - REQUIRE(doa != NULL); - REQUIRE(doa->common.rdtype == dns_rdatatype_doa); - REQUIRE(doa->common.rdclass == rdclass); + REQUIRE(((dns_rdata_doa_t *)source) != NULL); + REQUIRE(((dns_rdata_doa_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_doa_t *)source)->common.rdtype == + dns_rdatatype_doa); + + doa = source; RETERR(uint32_tobuffer(doa->enterprise, target)); RETERR(uint32_tobuffer(doa->type, target)); @@ -205,14 +208,16 @@ fromstruct_doa(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_doa(ARGS_TOSTRUCT) { - dns_rdata_doa_t *doa = target; + dns_rdata_doa_t *doa; isc_region_t region; + REQUIRE(((dns_rdata_doa_t *)target) != NULL); REQUIRE(rdata != NULL); REQUIRE(rdata->type == dns_rdatatype_doa); - REQUIRE(doa != NULL); REQUIRE(rdata->length != 0); + doa = target; + doa->common.rdclass = rdata->rdclass; doa->common.rdtype = rdata->type; ISC_LINK_INIT(&doa->common, link); @@ -287,10 +292,13 @@ cleanup: static inline void freestruct_doa(ARGS_FREESTRUCT) { - dns_rdata_doa_t *doa = source; + dns_rdata_doa_t *doa; + + REQUIRE(((dns_rdata_doa_t *)source) != NULL); + REQUIRE(((dns_rdata_doa_t *)source)->common.rdtype == + dns_rdatatype_doa); - REQUIRE(doa != NULL); - REQUIRE(doa->common.rdtype == dns_rdatatype_doa); + doa = source; if (doa->mctx == NULL) { return; diff --git a/lib/dns/rdata/generic/ds_43.c b/lib/dns/rdata/generic/ds_43.c index 3e3780414ec..9420529183e 100644 --- a/lib/dns/rdata/generic/ds_43.c +++ b/lib/dns/rdata/generic/ds_43.c @@ -247,11 +247,13 @@ compare_ds(ARGS_COMPARE) { static inline isc_result_t generic_fromstruct_ds(ARGS_FROMSTRUCT) { - dns_rdata_ds_t *ds = source; + dns_rdata_ds_t *ds; - REQUIRE(ds != NULL); - REQUIRE(ds->common.rdtype == type); - REQUIRE(ds->common.rdclass == rdclass); + REQUIRE(((dns_rdata_ds_t *)source) != NULL); + REQUIRE(((dns_rdata_ds_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_ds_t *)source)->common.rdclass == rdclass); + + ds = source; UNUSED(type); UNUSED(rdclass); @@ -290,14 +292,16 @@ fromstruct_ds(ARGS_FROMSTRUCT) { static inline isc_result_t generic_tostruct_ds(ARGS_TOSTRUCT) { - dns_rdata_ds_t *ds = target; + dns_rdata_ds_t *ds; isc_region_t region; - REQUIRE(ds != NULL); REQUIRE(rdata->length != 0); - REQUIRE(ds->common.rdtype == rdata->type); - REQUIRE(ds->common.rdclass == rdata->rdclass); - REQUIRE(!ISC_LINK_LINKED(&ds->common, link)); + REQUIRE(((dns_rdata_ds_t *)target) != NULL); + REQUIRE(((dns_rdata_ds_t *)target)->common.rdtype == rdata->type); + REQUIRE(((dns_rdata_ds_t *)target)->common.rdclass == rdata->rdclass); + REQUIRE(!ISC_LINK_LINKED(&((dns_rdata_ds_t *)target)->common, link)); + + ds = target; dns_rdata_toregion(rdata, ®ion); @@ -319,10 +323,12 @@ generic_tostruct_ds(ARGS_TOSTRUCT) { static inline isc_result_t tostruct_ds(ARGS_TOSTRUCT) { - dns_rdata_ds_t *ds = target; + dns_rdata_ds_t *ds; + REQUIRE(((dns_rdata_ds_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_ds); - REQUIRE(ds != NULL); + + ds = target; ds->common.rdclass = rdata->rdclass; ds->common.rdtype = rdata->type; @@ -333,10 +339,12 @@ tostruct_ds(ARGS_TOSTRUCT) { static inline void freestruct_ds(ARGS_FREESTRUCT) { - dns_rdata_ds_t *ds = source; + dns_rdata_ds_t *ds; + + REQUIRE(((dns_rdata_ds_t *)source) != NULL); + REQUIRE(((dns_rdata_ds_t *)source)->common.rdtype == dns_rdatatype_ds); - REQUIRE(ds != NULL); - REQUIRE(ds->common.rdtype == dns_rdatatype_ds); + ds = source; if (ds->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/eui48_108.c b/lib/dns/rdata/generic/eui48_108.c index 7a65eb421bd..14aa81240c6 100644 --- a/lib/dns/rdata/generic/eui48_108.c +++ b/lib/dns/rdata/generic/eui48_108.c @@ -110,12 +110,14 @@ compare_eui48(ARGS_COMPARE) { static inline isc_result_t fromstruct_eui48(ARGS_FROMSTRUCT) { - dns_rdata_eui48_t *eui48 = source; + dns_rdata_eui48_t *eui48; REQUIRE(type == dns_rdatatype_eui48); - REQUIRE(eui48 != NULL); - REQUIRE(eui48->common.rdtype == type); - REQUIRE(eui48->common.rdclass == rdclass); + REQUIRE(((dns_rdata_eui48_t *)source) != NULL); + REQUIRE(((dns_rdata_eui48_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_eui48_t *)source)->common.rdclass == rdclass); + + eui48 = source; UNUSED(type); UNUSED(rdclass); @@ -125,12 +127,14 @@ fromstruct_eui48(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_eui48(ARGS_TOSTRUCT) { - dns_rdata_eui48_t *eui48 = target; + dns_rdata_eui48_t *eui48; + REQUIRE(((dns_rdata_eui48_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_eui48); - REQUIRE(eui48 != NULL); REQUIRE(rdata->length == 6); + eui48 = target; + UNUSED(mctx); eui48->common.rdclass = rdata->rdclass; @@ -143,10 +147,9 @@ tostruct_eui48(ARGS_TOSTRUCT) { static inline void freestruct_eui48(ARGS_FREESTRUCT) { - dns_rdata_eui48_t *eui48 = source; - - REQUIRE(eui48 != NULL); - REQUIRE(eui48->common.rdtype == dns_rdatatype_eui48); + REQUIRE(((dns_rdata_eui48_t *)source) != NULL); + REQUIRE(((dns_rdata_eui48_t *)source)->common.rdtype == + dns_rdatatype_eui48); return; } diff --git a/lib/dns/rdata/generic/eui64_109.c b/lib/dns/rdata/generic/eui64_109.c index 941f3c37478..cb5844533cd 100644 --- a/lib/dns/rdata/generic/eui64_109.c +++ b/lib/dns/rdata/generic/eui64_109.c @@ -115,12 +115,14 @@ compare_eui64(ARGS_COMPARE) { static inline isc_result_t fromstruct_eui64(ARGS_FROMSTRUCT) { - dns_rdata_eui64_t *eui64 = source; + dns_rdata_eui64_t *eui64; REQUIRE(type == dns_rdatatype_eui64); - REQUIRE(eui64 != NULL); - REQUIRE(eui64->common.rdtype == type); - REQUIRE(eui64->common.rdclass == rdclass); + REQUIRE(((dns_rdata_eui64_t *)source) != NULL); + REQUIRE(((dns_rdata_eui64_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_eui64_t *)source)->common.rdclass == rdclass); + + eui64 = source; UNUSED(type); UNUSED(rdclass); @@ -130,12 +132,14 @@ fromstruct_eui64(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_eui64(ARGS_TOSTRUCT) { - dns_rdata_eui64_t *eui64 = target; + dns_rdata_eui64_t *eui64; + REQUIRE(((dns_rdata_eui64_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_eui64); - REQUIRE(eui64 != NULL); REQUIRE(rdata->length == 8); + eui64 = target; + UNUSED(mctx); eui64->common.rdclass = rdata->rdclass; @@ -148,10 +152,9 @@ tostruct_eui64(ARGS_TOSTRUCT) { static inline void freestruct_eui64(ARGS_FREESTRUCT) { - dns_rdata_eui64_t *eui64 = source; - - REQUIRE(eui64 != NULL); - REQUIRE(eui64->common.rdtype == dns_rdatatype_eui64); + REQUIRE(((dns_rdata_eui64_t *)source) != NULL); + REQUIRE(((dns_rdata_eui64_t *)source)->common.rdtype == + dns_rdatatype_eui64); return; } diff --git a/lib/dns/rdata/generic/gpos_27.c b/lib/dns/rdata/generic/gpos_27.c index ead5ca03327..20bf428ece9 100644 --- a/lib/dns/rdata/generic/gpos_27.c +++ b/lib/dns/rdata/generic/gpos_27.c @@ -104,12 +104,14 @@ compare_gpos(ARGS_COMPARE) { static inline isc_result_t fromstruct_gpos(ARGS_FROMSTRUCT) { - dns_rdata_gpos_t *gpos = source; + dns_rdata_gpos_t *gpos; REQUIRE(type == dns_rdatatype_gpos); - REQUIRE(gpos != NULL); - REQUIRE(gpos->common.rdtype == type); - REQUIRE(gpos->common.rdclass == rdclass); + REQUIRE(((dns_rdata_gpos_t *)source) != NULL); + REQUIRE(((dns_rdata_gpos_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_gpos_t *)source)->common.rdclass == rdclass); + + gpos = source; UNUSED(type); UNUSED(rdclass); @@ -124,13 +126,15 @@ fromstruct_gpos(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_gpos(ARGS_TOSTRUCT) { - dns_rdata_gpos_t *gpos = target; + dns_rdata_gpos_t *gpos; isc_region_t region; + REQUIRE(((dns_rdata_gpos_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_gpos); - REQUIRE(gpos != NULL); REQUIRE(rdata->length != 0); + gpos = target; + gpos->common.rdclass = rdata->rdclass; gpos->common.rdtype = rdata->type; ISC_LINK_INIT(&gpos->common, link); @@ -175,10 +179,13 @@ tostruct_gpos(ARGS_TOSTRUCT) { static inline void freestruct_gpos(ARGS_FREESTRUCT) { - dns_rdata_gpos_t *gpos = source; + dns_rdata_gpos_t *gpos; + + REQUIRE(((dns_rdata_gpos_t *)source) != NULL); + REQUIRE(((dns_rdata_gpos_t *)source)->common.rdtype == + dns_rdatatype_gpos); - REQUIRE(gpos != NULL); - REQUIRE(gpos->common.rdtype == dns_rdatatype_gpos); + gpos = source; if (gpos->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/hinfo_13.c b/lib/dns/rdata/generic/hinfo_13.c index 0d43a19fb9b..8204202ffd9 100644 --- a/lib/dns/rdata/generic/hinfo_13.c +++ b/lib/dns/rdata/generic/hinfo_13.c @@ -94,12 +94,14 @@ compare_hinfo(ARGS_COMPARE) { static inline isc_result_t fromstruct_hinfo(ARGS_FROMSTRUCT) { - dns_rdata_hinfo_t *hinfo = source; + dns_rdata_hinfo_t *hinfo; REQUIRE(type == dns_rdatatype_hinfo); - REQUIRE(hinfo != NULL); - REQUIRE(hinfo->common.rdtype == type); - REQUIRE(hinfo->common.rdclass == rdclass); + REQUIRE(((dns_rdata_hinfo_t *)source) != NULL); + REQUIRE(((dns_rdata_hinfo_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_hinfo_t *)source)->common.rdclass == rdclass); + + hinfo = source; UNUSED(type); UNUSED(rdclass); @@ -112,13 +114,15 @@ fromstruct_hinfo(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_hinfo(ARGS_TOSTRUCT) { - dns_rdata_hinfo_t *hinfo = target; + dns_rdata_hinfo_t *hinfo; isc_region_t region; + REQUIRE(((dns_rdata_hinfo_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_hinfo); - REQUIRE(hinfo != NULL); REQUIRE(rdata->length != 0); + hinfo = target; + hinfo->common.rdclass = rdata->rdclass; hinfo->common.rdtype = rdata->type; ISC_LINK_INIT(&hinfo->common, link); @@ -148,9 +152,11 @@ tostruct_hinfo(ARGS_TOSTRUCT) { static inline void freestruct_hinfo(ARGS_FREESTRUCT) { - dns_rdata_hinfo_t *hinfo = source; + dns_rdata_hinfo_t *hinfo; + + REQUIRE(((dns_rdata_hinfo_t *)source) != NULL); - REQUIRE(hinfo != NULL); + hinfo = source; if (hinfo->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/hip_55.c b/lib/dns/rdata/generic/hip_55.c index 7c8f31b1483..3702865c558 100644 --- a/lib/dns/rdata/generic/hip_55.c +++ b/lib/dns/rdata/generic/hip_55.c @@ -249,18 +249,26 @@ compare_hip(ARGS_COMPARE) { static inline isc_result_t fromstruct_hip(ARGS_FROMSTRUCT) { - dns_rdata_hip_t *hip = source; + dns_rdata_hip_t *hip; dns_rdata_hip_t myhip; isc_result_t result; REQUIRE(type == dns_rdatatype_hip); - REQUIRE(hip != NULL); - REQUIRE(hip->common.rdtype == type); - REQUIRE(hip->common.rdclass == rdclass); - REQUIRE(hip->hit_len > 0 && hip->hit != NULL); - REQUIRE(hip->key_len > 0 && hip->key != NULL); - REQUIRE((hip->servers == NULL && hip->servers_len == 0) || - (hip->servers != NULL && hip->servers_len != 0)); + REQUIRE(((dns_rdata_hip_t *)source) != NULL); + REQUIRE(((dns_rdata_hip_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_hip_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_hip_t *)source)->hit_len > 0); + REQUIRE(((dns_rdata_hip_t *)source)->hit != NULL); + REQUIRE(((dns_rdata_hip_t *)source)->key_len > 0); + REQUIRE(((dns_rdata_hip_t *)source)->key != NULL); + REQUIRE(((dns_rdata_hip_t *)source)->servers == NULL); + REQUIRE(((dns_rdata_hip_t *)source)->servers_len == 0); + REQUIRE((((dns_rdata_hip_t *)source)->servers == NULL && + ((dns_rdata_hip_t *)source)->servers_len == 0) || + (((dns_rdata_hip_t *)source)->servers != NULL && + ((dns_rdata_hip_t *)source)->servers_len != 0)); + + hip = source; UNUSED(type); UNUSED(rdclass); @@ -283,12 +291,14 @@ fromstruct_hip(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_hip(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_hip_t *hip = target; + dns_rdata_hip_t *hip; + REQUIRE(((dns_rdata_hip_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_hip); - REQUIRE(hip != NULL); REQUIRE(rdata->length != 0); + hip = target; + hip->common.rdclass = rdata->rdclass; hip->common.rdtype = rdata->type; ISC_LINK_INIT(&hip->common, link); @@ -342,9 +352,11 @@ tostruct_hip(ARGS_TOSTRUCT) { static inline void freestruct_hip(ARGS_FREESTRUCT) { - dns_rdata_hip_t *hip = source; + dns_rdata_hip_t *hip; + + REQUIRE(((dns_rdata_hip_t *)source) != NULL); - REQUIRE(hip != NULL); + hip = source; if (hip->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/ipseckey_45.c b/lib/dns/rdata/generic/ipseckey_45.c index 908f64f362e..95d17a3d660 100644 --- a/lib/dns/rdata/generic/ipseckey_45.c +++ b/lib/dns/rdata/generic/ipseckey_45.c @@ -277,14 +277,16 @@ compare_ipseckey(ARGS_COMPARE) { static inline isc_result_t fromstruct_ipseckey(ARGS_FROMSTRUCT) { - dns_rdata_ipseckey_t *ipseckey = source; + dns_rdata_ipseckey_t *ipseckey; isc_region_t region; uint32_t n; REQUIRE(type == dns_rdatatype_ipseckey); - REQUIRE(ipseckey != NULL); - REQUIRE(ipseckey->common.rdtype == type); - REQUIRE(ipseckey->common.rdclass == rdclass); + REQUIRE(((dns_rdata_ipseckey_t *)source) != NULL); + REQUIRE(((dns_rdata_ipseckey_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_ipseckey_t *)source)->common.rdclass == rdclass); + + ipseckey = source; UNUSED(type); UNUSED(rdclass); @@ -321,14 +323,16 @@ fromstruct_ipseckey(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_ipseckey(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_ipseckey_t *ipseckey = target; + dns_rdata_ipseckey_t *ipseckey; dns_name_t name; uint32_t n; + REQUIRE(((dns_rdata_ipseckey_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_ipseckey); - REQUIRE(ipseckey != NULL); REQUIRE(rdata->length >= 3); + ipseckey = target; + if (rdata->data[1] > 3U) return (ISC_R_NOTIMPLEMENTED); @@ -390,10 +394,13 @@ tostruct_ipseckey(ARGS_TOSTRUCT) { static inline void freestruct_ipseckey(ARGS_FREESTRUCT) { - dns_rdata_ipseckey_t *ipseckey = source; + dns_rdata_ipseckey_t *ipseckey; + + REQUIRE(((dns_rdata_ipseckey_t *)source) != NULL); + REQUIRE(((dns_rdata_ipseckey_t *)source)->common.rdtype == + dns_rdatatype_ipseckey); - REQUIRE(ipseckey != NULL); - REQUIRE(ipseckey->common.rdtype == dns_rdatatype_ipseckey); + ipseckey = source; if (ipseckey->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/isdn_20.c b/lib/dns/rdata/generic/isdn_20.c index 586142ecefe..eaab98694e0 100644 --- a/lib/dns/rdata/generic/isdn_20.c +++ b/lib/dns/rdata/generic/isdn_20.c @@ -105,12 +105,14 @@ compare_isdn(ARGS_COMPARE) { static inline isc_result_t fromstruct_isdn(ARGS_FROMSTRUCT) { - dns_rdata_isdn_t *isdn = source; + dns_rdata_isdn_t *isdn; REQUIRE(type == dns_rdatatype_isdn); - REQUIRE(isdn != NULL); - REQUIRE(isdn->common.rdtype == type); - REQUIRE(isdn->common.rdclass == rdclass); + REQUIRE(((dns_rdata_isdn_t *)source) != NULL); + REQUIRE(((dns_rdata_isdn_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_isdn_t *)source)->common.rdclass == rdclass); + + isdn = source; UNUSED(type); UNUSED(rdclass); @@ -125,13 +127,15 @@ fromstruct_isdn(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_isdn(ARGS_TOSTRUCT) { - dns_rdata_isdn_t *isdn = target; + dns_rdata_isdn_t *isdn; isc_region_t r; + REQUIRE(((dns_rdata_isdn_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_isdn); - REQUIRE(isdn != NULL); REQUIRE(rdata->length != 0); + isdn = target; + isdn->common.rdclass = rdata->rdclass; isdn->common.rdtype = rdata->type; ISC_LINK_INIT(&isdn->common, link); @@ -168,9 +172,11 @@ tostruct_isdn(ARGS_TOSTRUCT) { static inline void freestruct_isdn(ARGS_FREESTRUCT) { - dns_rdata_isdn_t *isdn = source; + dns_rdata_isdn_t *isdn; + + REQUIRE(((dns_rdata_isdn_t *)source) != NULL); - REQUIRE(isdn != NULL); + isdn = source; if (isdn->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/key_25.c b/lib/dns/rdata/generic/key_25.c index bd64c90540b..5be6df125e9 100644 --- a/lib/dns/rdata/generic/key_25.c +++ b/lib/dns/rdata/generic/key_25.c @@ -306,11 +306,13 @@ compare_key(ARGS_COMPARE) { static inline isc_result_t generic_fromstruct_key(ARGS_FROMSTRUCT) { - dns_rdata_key_t *key = source; + dns_rdata_key_t *key; - REQUIRE(key != NULL); - REQUIRE(key->common.rdtype == type); - REQUIRE(key->common.rdclass == rdclass); + REQUIRE(((dns_rdata_key_t *)source) != NULL); + REQUIRE(((dns_rdata_key_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_key_t *)source)->common.rdclass == rdclass); + + key = source; UNUSED(type); UNUSED(rdclass); @@ -334,16 +336,16 @@ generic_fromstruct_key(ARGS_FROMSTRUCT) { static inline isc_result_t generic_tostruct_key(ARGS_TOSTRUCT) { - dns_rdata_key_t *key = target; + dns_rdata_key_t *key; isc_region_t sr; - REQUIRE(key != NULL); REQUIRE(rdata->length != 0); + REQUIRE(((dns_rdata_key_t *)target) != NULL); + REQUIRE(((dns_rdata_key_t *)target)->common.rdclass == rdata->rdclass); + REQUIRE(((dns_rdata_key_t *)target)->common.rdtype == rdata->type); + REQUIRE(!ISC_LINK_LINKED(&((dns_rdata_key_t *)target)->common, link)); - REQUIRE(key != NULL); - REQUIRE(key->common.rdclass == rdata->rdclass); - REQUIRE(key->common.rdtype == rdata->type); - REQUIRE(!ISC_LINK_LINKED(&key->common, link)); + key = target; dns_rdata_toregion(rdata, &sr); @@ -377,9 +379,11 @@ generic_tostruct_key(ARGS_TOSTRUCT) { static inline void generic_freestruct_key(ARGS_FREESTRUCT) { - dns_rdata_key_t *key = (dns_rdata_key_t *) source; + dns_rdata_key_t *key; + + REQUIRE(((dns_rdata_key_t *)source) != NULL); - REQUIRE(key != NULL); + key = (dns_rdata_key_t *) source; if (key->mctx == NULL) return; @@ -399,12 +403,14 @@ fromstruct_key(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_key(ARGS_TOSTRUCT) { - dns_rdata_key_t *key = target; + dns_rdata_key_t *key; - REQUIRE(key != NULL); + REQUIRE(((dns_rdata_key_t *)target) != NULL); REQUIRE(rdata != NULL); REQUIRE(rdata->type == dns_rdatatype_key); + key = target; + key->common.rdclass = rdata->rdclass; key->common.rdtype = rdata->type; ISC_LINK_INIT(&key->common, link); @@ -414,10 +420,9 @@ tostruct_key(ARGS_TOSTRUCT) { static inline void freestruct_key(ARGS_FREESTRUCT) { - dns_rdata_key_t *key = (dns_rdata_key_t *) source; - - REQUIRE(key != NULL); - REQUIRE(key->common.rdtype == dns_rdatatype_key); + REQUIRE(((dns_rdata_key_t *)source) != NULL); + REQUIRE(((dns_rdata_key_t *)source)->common.rdtype == + dns_rdatatype_key); generic_freestruct_key(source); } diff --git a/lib/dns/rdata/generic/keydata_65533.c b/lib/dns/rdata/generic/keydata_65533.c index 575083c817a..376e4a7d5c7 100644 --- a/lib/dns/rdata/generic/keydata_65533.c +++ b/lib/dns/rdata/generic/keydata_65533.c @@ -281,12 +281,14 @@ compare_keydata(ARGS_COMPARE) { static inline isc_result_t fromstruct_keydata(ARGS_FROMSTRUCT) { - dns_rdata_keydata_t *keydata = source; + dns_rdata_keydata_t *keydata; REQUIRE(type == dns_rdatatype_keydata); - REQUIRE(keydata != NULL); - REQUIRE(keydata->common.rdtype == type); - REQUIRE(keydata->common.rdclass == rdclass); + REQUIRE(((dns_rdata_keydata_t *)source) != NULL); + REQUIRE(((dns_rdata_keydata_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_keydata_t *)source)->common.rdclass == rdclass); + + keydata = source; UNUSED(type); UNUSED(rdclass); @@ -315,11 +317,13 @@ fromstruct_keydata(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_keydata(ARGS_TOSTRUCT) { - dns_rdata_keydata_t *keydata = target; - isc_region_t sr; + dns_rdata_keydata_t *keydata; REQUIRE(rdata->type == dns_rdatatype_keydata); - REQUIRE(keydata != NULL); + REQUIRE(((dns_rdata_keydata_t *)target) != NULL); + + keydata = target; + isc_region_t sr; keydata->common.rdclass = rdata->rdclass; keydata->common.rdtype = rdata->type; @@ -375,10 +379,13 @@ tostruct_keydata(ARGS_TOSTRUCT) { static inline void freestruct_keydata(ARGS_FREESTRUCT) { - dns_rdata_keydata_t *keydata = (dns_rdata_keydata_t *) source; + dns_rdata_keydata_t *keydata; + + REQUIRE(((dns_rdata_keydata_t *)source) != NULL); + REQUIRE(((dns_rdata_keydata_t *)source)->common.rdtype == + dns_rdatatype_keydata); - REQUIRE(keydata != NULL); - REQUIRE(keydata->common.rdtype == dns_rdatatype_keydata); + keydata = (dns_rdata_keydata_t *) source; if (keydata->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/l32_105.c b/lib/dns/rdata/generic/l32_105.c index 0f44bf9c517..dffa96b1c04 100644 --- a/lib/dns/rdata/generic/l32_105.c +++ b/lib/dns/rdata/generic/l32_105.c @@ -120,13 +120,15 @@ compare_l32(ARGS_COMPARE) { static inline isc_result_t fromstruct_l32(ARGS_FROMSTRUCT) { - dns_rdata_l32_t *l32 = source; + dns_rdata_l32_t *l32; uint32_t n; REQUIRE(type == dns_rdatatype_l32); - REQUIRE(l32 != NULL); - REQUIRE(l32->common.rdtype == type); - REQUIRE(l32->common.rdclass == rdclass); + REQUIRE(((dns_rdata_l32_t *)source) != NULL); + REQUIRE(((dns_rdata_l32_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_l32_t *)source)->common.rdclass == rdclass); + + l32 = source; UNUSED(type); UNUSED(rdclass); @@ -139,13 +141,15 @@ fromstruct_l32(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_l32(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_l32_t *l32 = target; + dns_rdata_l32_t *l32; uint32_t n; + REQUIRE(((dns_rdata_l32_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_l32); - REQUIRE(l32 != NULL); REQUIRE(rdata->length == 6); + l32 = target; + UNUSED(mctx); l32->common.rdclass = rdata->rdclass; @@ -161,10 +165,9 @@ tostruct_l32(ARGS_TOSTRUCT) { static inline void freestruct_l32(ARGS_FREESTRUCT) { - dns_rdata_l32_t *l32 = source; - - REQUIRE(l32 != NULL); - REQUIRE(l32->common.rdtype == dns_rdatatype_l32); + REQUIRE(((dns_rdata_l32_t *)source) != NULL); + REQUIRE(((dns_rdata_l32_t *)source)->common.rdtype == + dns_rdatatype_l32); return; } diff --git a/lib/dns/rdata/generic/l64_106.c b/lib/dns/rdata/generic/l64_106.c index a3e7ab1b0a6..33301988248 100644 --- a/lib/dns/rdata/generic/l64_106.c +++ b/lib/dns/rdata/generic/l64_106.c @@ -119,12 +119,14 @@ compare_l64(ARGS_COMPARE) { static inline isc_result_t fromstruct_l64(ARGS_FROMSTRUCT) { - dns_rdata_l64_t *l64 = source; + dns_rdata_l64_t *l64; REQUIRE(type == dns_rdatatype_l64); - REQUIRE(l64 != NULL); - REQUIRE(l64->common.rdtype == type); - REQUIRE(l64->common.rdclass == rdclass); + REQUIRE(((dns_rdata_l64_t *)source) != NULL); + REQUIRE(((dns_rdata_l64_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_l64_t *)source)->common.rdclass == rdclass); + + l64 = source; UNUSED(type); UNUSED(rdclass); @@ -136,12 +138,14 @@ fromstruct_l64(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_l64(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_l64_t *l64 = target; + dns_rdata_l64_t *l64; + REQUIRE(((dns_rdata_l64_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_l64); - REQUIRE(l64 != NULL); REQUIRE(rdata->length == 10); + l64 = target; + UNUSED(mctx); l64->common.rdclass = rdata->rdclass; @@ -156,10 +160,9 @@ tostruct_l64(ARGS_TOSTRUCT) { static inline void freestruct_l64(ARGS_FREESTRUCT) { - dns_rdata_l64_t *l64 = source; - - REQUIRE(l64 != NULL); - REQUIRE(l64->common.rdtype == dns_rdatatype_l64); + REQUIRE(((dns_rdata_l64_t *)source) != NULL); + REQUIRE(((dns_rdata_l64_t *)source)->common.rdtype == + dns_rdatatype_l64); return; } diff --git a/lib/dns/rdata/generic/loc_29.c b/lib/dns/rdata/generic/loc_29.c index 792c8e73003..af9343654da 100644 --- a/lib/dns/rdata/generic/loc_29.c +++ b/lib/dns/rdata/generic/loc_29.c @@ -666,13 +666,15 @@ compare_loc(ARGS_COMPARE) { static inline isc_result_t fromstruct_loc(ARGS_FROMSTRUCT) { - dns_rdata_loc_t *loc = source; + dns_rdata_loc_t *loc; uint8_t c; REQUIRE(type == dns_rdatatype_loc); - REQUIRE(loc != NULL); - REQUIRE(loc->common.rdtype == type); - REQUIRE(loc->common.rdclass == rdclass); + REQUIRE(((dns_rdata_loc_t *)source) != NULL); + REQUIRE(((dns_rdata_loc_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_loc_t *)source)->common.rdclass == rdclass); + + loc = source; UNUSED(type); UNUSED(rdclass); @@ -710,14 +712,16 @@ fromstruct_loc(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_loc(ARGS_TOSTRUCT) { - dns_rdata_loc_t *loc = target; + dns_rdata_loc_t *loc; isc_region_t r; uint8_t version; + REQUIRE(((dns_rdata_loc_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_loc); - REQUIRE(loc != NULL); REQUIRE(rdata->length != 0); + loc = target; + UNUSED(mctx); dns_rdata_toregion(rdata, &r); @@ -748,10 +752,13 @@ tostruct_loc(ARGS_TOSTRUCT) { static inline void freestruct_loc(ARGS_FREESTRUCT) { - dns_rdata_loc_t *loc = source; + dns_rdata_loc_t *loc; + + REQUIRE(((dns_rdata_loc_t *)source) != NULL); + REQUIRE(((dns_rdata_loc_t *)source)->common.rdtype == + dns_rdatatype_loc); - REQUIRE(loc != NULL); - REQUIRE(loc->common.rdtype == dns_rdatatype_loc); + loc = source; UNUSED(source); UNUSED(loc); diff --git a/lib/dns/rdata/generic/lp_107.c b/lib/dns/rdata/generic/lp_107.c index 87e268f7f69..bb952663367 100644 --- a/lib/dns/rdata/generic/lp_107.c +++ b/lib/dns/rdata/generic/lp_107.c @@ -126,13 +126,15 @@ compare_lp(ARGS_COMPARE) { static inline isc_result_t fromstruct_lp(ARGS_FROMSTRUCT) { - dns_rdata_lp_t *lp = source; + dns_rdata_lp_t *lp; isc_region_t region; REQUIRE(type == dns_rdatatype_lp); - REQUIRE(lp != NULL); - REQUIRE(lp->common.rdtype == type); - REQUIRE(lp->common.rdclass == rdclass); + REQUIRE(((dns_rdata_lp_t *)source) != NULL); + REQUIRE(((dns_rdata_lp_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_lp_t *)source)->common.rdclass == rdclass); + + lp = source; UNUSED(type); UNUSED(rdclass); @@ -145,13 +147,15 @@ fromstruct_lp(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_lp(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_lp_t *lp = target; + dns_rdata_lp_t *lp; dns_name_t name; + REQUIRE(((dns_rdata_lp_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_lp); - REQUIRE(lp != NULL); REQUIRE(rdata->length != 0); + lp = target; + lp->common.rdclass = rdata->rdclass; lp->common.rdtype = rdata->type; ISC_LINK_INIT(&lp->common, link); @@ -169,10 +173,12 @@ tostruct_lp(ARGS_TOSTRUCT) { static inline void freestruct_lp(ARGS_FREESTRUCT) { - dns_rdata_lp_t *lp = source; + dns_rdata_lp_t *lp; + + REQUIRE(((dns_rdata_lp_t *)source) != NULL); + REQUIRE(((dns_rdata_lp_t *)source)->common.rdtype == dns_rdatatype_lp); - REQUIRE(lp != NULL); - REQUIRE(lp->common.rdtype == dns_rdatatype_lp); + lp = source; if (lp->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/mb_7.c b/lib/dns/rdata/generic/mb_7.c index 93d85e52bc1..3792ddbc89e 100644 --- a/lib/dns/rdata/generic/mb_7.c +++ b/lib/dns/rdata/generic/mb_7.c @@ -118,13 +118,15 @@ compare_mb(ARGS_COMPARE) { static inline isc_result_t fromstruct_mb(ARGS_FROMSTRUCT) { - dns_rdata_mb_t *mb = source; + dns_rdata_mb_t *mb; isc_region_t region; REQUIRE(type == dns_rdatatype_mb); - REQUIRE(mb != NULL); - REQUIRE(mb->common.rdtype == type); - REQUIRE(mb->common.rdclass == rdclass); + REQUIRE(((dns_rdata_mb_t *)source) != NULL); + REQUIRE(((dns_rdata_mb_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_mb_t *)source)->common.rdclass == rdclass); + + mb = source; UNUSED(type); UNUSED(rdclass); @@ -136,13 +138,15 @@ fromstruct_mb(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_mb(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_mb_t *mb = target; + dns_rdata_mb_t *mb; dns_name_t name; + REQUIRE(((dns_rdata_mb_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_mb); - REQUIRE(mb != NULL); REQUIRE(rdata->length != 0); + mb = target; + mb->common.rdclass = rdata->rdclass; mb->common.rdtype = rdata->type; ISC_LINK_INIT(&mb->common, link); @@ -158,9 +162,11 @@ tostruct_mb(ARGS_TOSTRUCT) { static inline void freestruct_mb(ARGS_FREESTRUCT) { - dns_rdata_mb_t *mb = source; + dns_rdata_mb_t *mb; + + REQUIRE(((dns_rdata_mb_t *)source) != NULL); - REQUIRE(mb != NULL); + mb = source; if (mb->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/md_3.c b/lib/dns/rdata/generic/md_3.c index 8c58d6e8c93..9048670ab4b 100644 --- a/lib/dns/rdata/generic/md_3.c +++ b/lib/dns/rdata/generic/md_3.c @@ -118,13 +118,15 @@ compare_md(ARGS_COMPARE) { static inline isc_result_t fromstruct_md(ARGS_FROMSTRUCT) { - dns_rdata_md_t *md = source; + dns_rdata_md_t *md; isc_region_t region; REQUIRE(type == dns_rdatatype_md); - REQUIRE(md != NULL); - REQUIRE(md->common.rdtype == type); - REQUIRE(md->common.rdclass == rdclass); + REQUIRE(((dns_rdata_md_t *)source) != NULL); + REQUIRE(((dns_rdata_md_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_md_t *)source)->common.rdclass == rdclass); + + md = source; UNUSED(type); UNUSED(rdclass); @@ -135,14 +137,16 @@ fromstruct_md(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_md(ARGS_TOSTRUCT) { - dns_rdata_md_t *md = target; + dns_rdata_md_t *md; isc_region_t r; dns_name_t name; + REQUIRE(((dns_rdata_md_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_md); - REQUIRE(md != NULL); REQUIRE(rdata->length != 0); + md = target; + md->common.rdclass = rdata->rdclass; md->common.rdtype = rdata->type; ISC_LINK_INIT(&md->common, link); @@ -158,10 +162,12 @@ tostruct_md(ARGS_TOSTRUCT) { static inline void freestruct_md(ARGS_FREESTRUCT) { - dns_rdata_md_t *md = source; + dns_rdata_md_t *md; + + REQUIRE(((dns_rdata_md_t *)source) != NULL); + REQUIRE(((dns_rdata_md_t *)source)->common.rdtype == dns_rdatatype_md); - REQUIRE(md != NULL); - REQUIRE(md->common.rdtype == dns_rdatatype_md); + md = source; if (md->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/mf_4.c b/lib/dns/rdata/generic/mf_4.c index fa653a683c3..ea8921636fc 100644 --- a/lib/dns/rdata/generic/mf_4.c +++ b/lib/dns/rdata/generic/mf_4.c @@ -118,13 +118,15 @@ compare_mf(ARGS_COMPARE) { static inline isc_result_t fromstruct_mf(ARGS_FROMSTRUCT) { - dns_rdata_mf_t *mf = source; + dns_rdata_mf_t *mf; isc_region_t region; REQUIRE(type == dns_rdatatype_mf); - REQUIRE(mf != NULL); - REQUIRE(mf->common.rdtype == type); - REQUIRE(mf->common.rdclass == rdclass); + REQUIRE(((dns_rdata_mf_t *)source) != NULL); + REQUIRE(((dns_rdata_mf_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_mf_t *)source)->common.rdclass == rdclass); + + mf = source; UNUSED(type); UNUSED(rdclass); @@ -135,14 +137,16 @@ fromstruct_mf(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_mf(ARGS_TOSTRUCT) { - dns_rdata_mf_t *mf = target; + dns_rdata_mf_t *mf; isc_region_t r; dns_name_t name; + REQUIRE(((dns_rdata_mf_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_mf); - REQUIRE(mf != NULL); REQUIRE(rdata->length != 0); + mf = target; + mf->common.rdclass = rdata->rdclass; mf->common.rdtype = rdata->type; ISC_LINK_INIT(&mf->common, link); @@ -158,10 +162,12 @@ tostruct_mf(ARGS_TOSTRUCT) { static inline void freestruct_mf(ARGS_FREESTRUCT) { - dns_rdata_mf_t *mf = source; + dns_rdata_mf_t *mf; + + REQUIRE(((dns_rdata_mf_t *)source) != NULL); + REQUIRE(((dns_rdata_mf_t *)source)->common.rdtype == dns_rdatatype_mf); - REQUIRE(mf != NULL); - REQUIRE(mf->common.rdtype == dns_rdatatype_mf); + mf = source; if (mf->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/mg_8.c b/lib/dns/rdata/generic/mg_8.c index c631539d206..2052ec1caf5 100644 --- a/lib/dns/rdata/generic/mg_8.c +++ b/lib/dns/rdata/generic/mg_8.c @@ -118,13 +118,15 @@ compare_mg(ARGS_COMPARE) { static inline isc_result_t fromstruct_mg(ARGS_FROMSTRUCT) { - dns_rdata_mg_t *mg = source; + dns_rdata_mg_t *mg; isc_region_t region; REQUIRE(type == dns_rdatatype_mg); - REQUIRE(mg != NULL); - REQUIRE(mg->common.rdtype == type); - REQUIRE(mg->common.rdclass == rdclass); + REQUIRE(((dns_rdata_mg_t *)source) != NULL); + REQUIRE(((dns_rdata_mg_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_mg_t *)source)->common.rdclass == rdclass); + + mg = source; UNUSED(type); UNUSED(rdclass); @@ -136,13 +138,15 @@ fromstruct_mg(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_mg(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_mg_t *mg = target; + dns_rdata_mg_t *mg; dns_name_t name; + REQUIRE(((dns_rdata_mg_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_mg); - REQUIRE(mg != NULL); REQUIRE(rdata->length != 0); + mg = target; + mg->common.rdclass = rdata->rdclass; mg->common.rdtype = rdata->type; ISC_LINK_INIT(&mg->common, link); @@ -158,10 +162,12 @@ tostruct_mg(ARGS_TOSTRUCT) { static inline void freestruct_mg(ARGS_FREESTRUCT) { - dns_rdata_mg_t *mg = source; + dns_rdata_mg_t *mg; + + REQUIRE(((dns_rdata_mg_t *)source) != NULL); + REQUIRE(((dns_rdata_mg_t *)source)->common.rdtype == dns_rdatatype_mg); - REQUIRE(mg != NULL); - REQUIRE(mg->common.rdtype == dns_rdatatype_mg); + mg = source; if (mg->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/minfo_14.c b/lib/dns/rdata/generic/minfo_14.c index 5b1e8745c79..1a81f67c97e 100644 --- a/lib/dns/rdata/generic/minfo_14.c +++ b/lib/dns/rdata/generic/minfo_14.c @@ -173,13 +173,15 @@ compare_minfo(ARGS_COMPARE) { static inline isc_result_t fromstruct_minfo(ARGS_FROMSTRUCT) { - dns_rdata_minfo_t *minfo = source; + dns_rdata_minfo_t *minfo; isc_region_t region; REQUIRE(type == dns_rdatatype_minfo); - REQUIRE(minfo != NULL); - REQUIRE(minfo->common.rdtype == type); - REQUIRE(minfo->common.rdclass == rdclass); + REQUIRE(((dns_rdata_minfo_t *)source) != NULL); + REQUIRE(((dns_rdata_minfo_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_minfo_t *)source)->common.rdclass == rdclass); + + minfo = source; UNUSED(type); UNUSED(rdclass); @@ -192,15 +194,17 @@ fromstruct_minfo(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_minfo(ARGS_TOSTRUCT) { - dns_rdata_minfo_t *minfo = target; + dns_rdata_minfo_t *minfo; isc_region_t region; dns_name_t name; isc_result_t result; + REQUIRE(((dns_rdata_minfo_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_minfo); - REQUIRE(minfo != NULL); REQUIRE(rdata->length != 0); + minfo = target; + minfo->common.rdclass = rdata->rdclass; minfo->common.rdtype = rdata->type; ISC_LINK_INIT(&minfo->common, link); @@ -228,10 +232,13 @@ tostruct_minfo(ARGS_TOSTRUCT) { static inline void freestruct_minfo(ARGS_FREESTRUCT) { - dns_rdata_minfo_t *minfo = source; + dns_rdata_minfo_t *minfo; + + REQUIRE(((dns_rdata_minfo_t *)source) != NULL); + REQUIRE(((dns_rdata_minfo_t *)source)->common.rdtype == + dns_rdatatype_minfo); - REQUIRE(minfo != NULL); - REQUIRE(minfo->common.rdtype == dns_rdatatype_minfo); + minfo = source; if (minfo->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/mr_9.c b/lib/dns/rdata/generic/mr_9.c index c39bf540839..78fb30b6915 100644 --- a/lib/dns/rdata/generic/mr_9.c +++ b/lib/dns/rdata/generic/mr_9.c @@ -118,13 +118,15 @@ compare_mr(ARGS_COMPARE) { static inline isc_result_t fromstruct_mr(ARGS_FROMSTRUCT) { - dns_rdata_mr_t *mr = source; + dns_rdata_mr_t *mr; isc_region_t region; REQUIRE(type == dns_rdatatype_mr); - REQUIRE(mr != NULL); - REQUIRE(mr->common.rdtype == type); - REQUIRE(mr->common.rdclass == rdclass); + REQUIRE(((dns_rdata_mr_t *)source) != NULL); + REQUIRE(((dns_rdata_mr_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_mr_t *)source)->common.rdclass == rdclass); + + mr = source; UNUSED(type); UNUSED(rdclass); @@ -136,13 +138,15 @@ fromstruct_mr(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_mr(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_mr_t *mr = target; + dns_rdata_mr_t *mr; dns_name_t name; + REQUIRE(((dns_rdata_mr_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_mr); - REQUIRE(mr != NULL); REQUIRE(rdata->length != 0); + mr = target; + mr->common.rdclass = rdata->rdclass; mr->common.rdtype = rdata->type; ISC_LINK_INIT(&mr->common, link); @@ -158,10 +162,12 @@ tostruct_mr(ARGS_TOSTRUCT) { static inline void freestruct_mr(ARGS_FREESTRUCT) { - dns_rdata_mr_t *mr = source; + dns_rdata_mr_t *mr; + + REQUIRE(((dns_rdata_mr_t *)source) != NULL); + REQUIRE(((dns_rdata_mr_t *)source)->common.rdtype == dns_rdatatype_mr); - REQUIRE(mr != NULL); - REQUIRE(mr->common.rdtype == dns_rdatatype_mr); + mr = source; if (mr->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/mx_15.c b/lib/dns/rdata/generic/mx_15.c index 95f37aef439..a37a66b54c9 100644 --- a/lib/dns/rdata/generic/mx_15.c +++ b/lib/dns/rdata/generic/mx_15.c @@ -188,13 +188,15 @@ compare_mx(ARGS_COMPARE) { static inline isc_result_t fromstruct_mx(ARGS_FROMSTRUCT) { - dns_rdata_mx_t *mx = source; + dns_rdata_mx_t *mx; isc_region_t region; REQUIRE(type == dns_rdatatype_mx); - REQUIRE(mx != NULL); - REQUIRE(mx->common.rdtype == type); - REQUIRE(mx->common.rdclass == rdclass); + REQUIRE(((dns_rdata_mx_t *)source) != NULL); + REQUIRE(((dns_rdata_mx_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_mx_t *)source)->common.rdclass == rdclass); + + mx = source; UNUSED(type); UNUSED(rdclass); @@ -207,13 +209,15 @@ fromstruct_mx(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_mx(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_mx_t *mx = target; + dns_rdata_mx_t *mx; dns_name_t name; + REQUIRE(((dns_rdata_mx_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_mx); - REQUIRE(mx != NULL); REQUIRE(rdata->length != 0); + mx = target; + mx->common.rdclass = rdata->rdclass; mx->common.rdtype = rdata->type; ISC_LINK_INIT(&mx->common, link); @@ -231,10 +235,12 @@ tostruct_mx(ARGS_TOSTRUCT) { static inline void freestruct_mx(ARGS_FREESTRUCT) { - dns_rdata_mx_t *mx = source; + dns_rdata_mx_t *mx; + + REQUIRE(((dns_rdata_mx_t *)source) != NULL); + REQUIRE(((dns_rdata_mx_t *)source)->common.rdtype == dns_rdatatype_mx); - REQUIRE(mx != NULL); - REQUIRE(mx->common.rdtype == dns_rdatatype_mx); + mx = source; if (mx->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/naptr_35.c b/lib/dns/rdata/generic/naptr_35.c index 4d99e2b2536..b1a717d7d29 100644 --- a/lib/dns/rdata/generic/naptr_35.c +++ b/lib/dns/rdata/generic/naptr_35.c @@ -398,16 +398,21 @@ compare_naptr(ARGS_COMPARE) { static inline isc_result_t fromstruct_naptr(ARGS_FROMSTRUCT) { - dns_rdata_naptr_t *naptr = source; + dns_rdata_naptr_t *naptr; isc_region_t region; REQUIRE(type == dns_rdatatype_naptr); - REQUIRE(naptr != NULL); - REQUIRE(naptr->common.rdtype == type); - REQUIRE(naptr->common.rdclass == rdclass); - REQUIRE(naptr->flags != NULL || naptr->flags_len == 0); - REQUIRE(naptr->service != NULL || naptr->service_len == 0); - REQUIRE(naptr->regexp != NULL || naptr->regexp_len == 0); + REQUIRE(((dns_rdata_naptr_t *)source) != NULL); + REQUIRE(((dns_rdata_naptr_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_naptr_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_naptr_t *)source)->flags != NULL || + ((dns_rdata_naptr_t *)source)->flags_len == 0); + REQUIRE(((dns_rdata_naptr_t *)source)->service != NULL || + ((dns_rdata_naptr_t *)source)->service_len == 0); + REQUIRE(((dns_rdata_naptr_t *)source)->regexp != NULL || + ((dns_rdata_naptr_t *)source)->regexp_len == 0); + + naptr = source; UNUSED(type); UNUSED(rdclass); @@ -426,15 +431,17 @@ fromstruct_naptr(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_naptr(ARGS_TOSTRUCT) { - dns_rdata_naptr_t *naptr = target; + dns_rdata_naptr_t *naptr; isc_region_t r; isc_result_t result; dns_name_t name; + REQUIRE(((dns_rdata_naptr_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_naptr); - REQUIRE(naptr != NULL); REQUIRE(rdata->length != 0); + naptr = target; + naptr->common.rdclass = rdata->rdclass; naptr->common.rdtype = rdata->type; ISC_LINK_INIT(&naptr->common, link); @@ -496,10 +503,13 @@ tostruct_naptr(ARGS_TOSTRUCT) { static inline void freestruct_naptr(ARGS_FREESTRUCT) { - dns_rdata_naptr_t *naptr = source; + dns_rdata_naptr_t *naptr; + + REQUIRE(((dns_rdata_naptr_t *)source) != NULL); + REQUIRE(((dns_rdata_naptr_t *)source)->common.rdtype == + dns_rdatatype_naptr); - REQUIRE(naptr != NULL); - REQUIRE(naptr->common.rdtype == dns_rdatatype_naptr); + naptr = source; if (naptr->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/nid_104.c b/lib/dns/rdata/generic/nid_104.c index 44e63b5ba7c..55faef68a77 100644 --- a/lib/dns/rdata/generic/nid_104.c +++ b/lib/dns/rdata/generic/nid_104.c @@ -119,12 +119,14 @@ compare_nid(ARGS_COMPARE) { static inline isc_result_t fromstruct_nid(ARGS_FROMSTRUCT) { - dns_rdata_nid_t *nid = source; + dns_rdata_nid_t *nid; REQUIRE(type == dns_rdatatype_nid); - REQUIRE(nid != NULL); - REQUIRE(nid->common.rdtype == type); - REQUIRE(nid->common.rdclass == rdclass); + REQUIRE(((dns_rdata_nid_t *)source) != NULL); + REQUIRE(((dns_rdata_nid_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_nid_t *)source)->common.rdclass == rdclass); + + nid = source; UNUSED(type); UNUSED(rdclass); @@ -136,12 +138,14 @@ fromstruct_nid(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_nid(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_nid_t *nid = target; + dns_rdata_nid_t *nid; + REQUIRE(((dns_rdata_nid_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_nid); - REQUIRE(nid != NULL); REQUIRE(rdata->length == 10); + nid = target; + UNUSED(mctx); nid->common.rdclass = rdata->rdclass; @@ -156,10 +160,9 @@ tostruct_nid(ARGS_TOSTRUCT) { static inline void freestruct_nid(ARGS_FREESTRUCT) { - dns_rdata_nid_t *nid = source; - - REQUIRE(nid != NULL); - REQUIRE(nid->common.rdtype == dns_rdatatype_nid); + REQUIRE(((dns_rdata_nid_t *)source) != NULL); + REQUIRE(((dns_rdata_nid_t *)source)->common.rdtype == + dns_rdatatype_nid); return; } diff --git a/lib/dns/rdata/generic/ninfo_56.c b/lib/dns/rdata/generic/ninfo_56.c index 1101ba1a77c..d7a6d187d80 100644 --- a/lib/dns/rdata/generic/ninfo_56.c +++ b/lib/dns/rdata/generic/ninfo_56.c @@ -87,10 +87,12 @@ fromstruct_ninfo(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_ninfo(ARGS_TOSTRUCT) { - dns_rdata_ninfo_t *ninfo = target; + dns_rdata_ninfo_t *ninfo; REQUIRE(rdata->type == dns_rdatatype_ninfo); - REQUIRE(ninfo != NULL); + REQUIRE(((dns_rdata_ninfo_t *)target) != NULL); + + ninfo = target; ninfo->common.rdclass = rdata->rdclass; ninfo->common.rdtype = rdata->type; @@ -101,10 +103,9 @@ tostruct_ninfo(ARGS_TOSTRUCT) { static inline void freestruct_ninfo(ARGS_FREESTRUCT) { - dns_rdata_ninfo_t *ninfo = source; - - REQUIRE(ninfo != NULL); - REQUIRE(ninfo->common.rdtype == dns_rdatatype_ninfo); + REQUIRE(((dns_rdata_ninfo_t *)source) != NULL); + REQUIRE(((dns_rdata_ninfo_t *)source)->common.rdtype == + dns_rdatatype_ninfo); generic_freestruct_txt(source); } diff --git a/lib/dns/rdata/generic/ns_2.c b/lib/dns/rdata/generic/ns_2.c index ac552529fbc..fcac93dddf5 100644 --- a/lib/dns/rdata/generic/ns_2.c +++ b/lib/dns/rdata/generic/ns_2.c @@ -126,13 +126,15 @@ compare_ns(ARGS_COMPARE) { static inline isc_result_t fromstruct_ns(ARGS_FROMSTRUCT) { - dns_rdata_ns_t *ns = source; + dns_rdata_ns_t *ns; isc_region_t region; REQUIRE(type == dns_rdatatype_ns); - REQUIRE(ns != NULL); - REQUIRE(ns->common.rdtype == type); - REQUIRE(ns->common.rdclass == rdclass); + REQUIRE(((dns_rdata_ns_t *)source) != NULL); + REQUIRE(((dns_rdata_ns_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_ns_t *)source)->common.rdclass == rdclass); + + ns = source; UNUSED(type); UNUSED(rdclass); @@ -144,13 +146,15 @@ fromstruct_ns(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_ns(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_ns_t *ns = target; + dns_rdata_ns_t *ns; dns_name_t name; + REQUIRE(((dns_rdata_ns_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_ns); - REQUIRE(ns != NULL); REQUIRE(rdata->length != 0); + ns = target; + ns->common.rdclass = rdata->rdclass; ns->common.rdtype = rdata->type; ISC_LINK_INIT(&ns->common, link); @@ -166,9 +170,11 @@ tostruct_ns(ARGS_TOSTRUCT) { static inline void freestruct_ns(ARGS_FREESTRUCT) { - dns_rdata_ns_t *ns = source; + dns_rdata_ns_t *ns; + + REQUIRE(((dns_rdata_ns_t *)source) != NULL); - REQUIRE(ns != NULL); + ns = source; if (ns->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/nsec3_50.c b/lib/dns/rdata/generic/nsec3_50.c index b1aee3e6705..f97388c7f8a 100644 --- a/lib/dns/rdata/generic/nsec3_50.c +++ b/lib/dns/rdata/generic/nsec3_50.c @@ -245,15 +245,18 @@ compare_nsec3(ARGS_COMPARE) { static inline isc_result_t fromstruct_nsec3(ARGS_FROMSTRUCT) { - dns_rdata_nsec3_t *nsec3 = source; + dns_rdata_nsec3_t *nsec3; isc_region_t region; REQUIRE(type == dns_rdatatype_nsec3); - REQUIRE(nsec3 != NULL); - REQUIRE(nsec3->common.rdtype == type); - REQUIRE(nsec3->common.rdclass == rdclass); - REQUIRE(nsec3->typebits != NULL || nsec3->len == 0); - REQUIRE(nsec3->hash == dns_hash_sha1); + REQUIRE(((dns_rdata_nsec3_t *)source) != NULL); + REQUIRE(((dns_rdata_nsec3_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_nsec3_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_nsec3_t *)source)->typebits != NULL || + ((dns_rdata_nsec3_t *)source)->len == 0); + REQUIRE(((dns_rdata_nsec3_t *)source)->hash == dns_hash_sha1); + + nsec3 = source; UNUSED(type); UNUSED(rdclass); @@ -275,12 +278,14 @@ fromstruct_nsec3(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_nsec3(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_nsec3_t *nsec3 = target; + dns_rdata_nsec3_t *nsec3; + REQUIRE(((dns_rdata_nsec3_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_nsec3); - REQUIRE(nsec3 != NULL); REQUIRE(rdata->length != 0); + nsec3 = target; + nsec3->common.rdclass = rdata->rdclass; nsec3->common.rdtype = rdata->type; ISC_LINK_INIT(&nsec3->common, link); @@ -320,10 +325,13 @@ tostruct_nsec3(ARGS_TOSTRUCT) { static inline void freestruct_nsec3(ARGS_FREESTRUCT) { - dns_rdata_nsec3_t *nsec3 = source; + dns_rdata_nsec3_t *nsec3; + + REQUIRE(((dns_rdata_nsec3_t *)source) != NULL); + REQUIRE(((dns_rdata_nsec3_t *)source)->common.rdtype == + dns_rdatatype_nsec3); - REQUIRE(nsec3 != NULL); - REQUIRE(nsec3->common.rdtype == dns_rdatatype_nsec3); + nsec3 = source; if (nsec3->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/nsec3param_51.c b/lib/dns/rdata/generic/nsec3param_51.c index 4e7c4c96faf..6140276b54b 100644 --- a/lib/dns/rdata/generic/nsec3param_51.c +++ b/lib/dns/rdata/generic/nsec3param_51.c @@ -195,12 +195,14 @@ compare_nsec3param(ARGS_COMPARE) { static inline isc_result_t fromstruct_nsec3param(ARGS_FROMSTRUCT) { - dns_rdata_nsec3param_t *nsec3param = source; + dns_rdata_nsec3param_t *nsec3param; REQUIRE(type == dns_rdatatype_nsec3param); - REQUIRE(nsec3param != NULL); - REQUIRE(nsec3param->common.rdtype == type); - REQUIRE(nsec3param->common.rdclass == rdclass); + REQUIRE(((dns_rdata_nsec3param_t *)source) != NULL); + REQUIRE(((dns_rdata_nsec3param_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_nsec3param_t *)source)->common.rdclass == rdclass); + + nsec3param = source; UNUSED(type); UNUSED(rdclass); @@ -217,12 +219,14 @@ fromstruct_nsec3param(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_nsec3param(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_nsec3param_t *nsec3param = target; + dns_rdata_nsec3param_t *nsec3param; + REQUIRE(((dns_rdata_nsec3param_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_nsec3param); - REQUIRE(nsec3param != NULL); REQUIRE(rdata->length != 0); + nsec3param = target; + nsec3param->common.rdclass = rdata->rdclass; nsec3param->common.rdtype = rdata->type; ISC_LINK_INIT(&nsec3param->common, link); @@ -246,10 +250,13 @@ tostruct_nsec3param(ARGS_TOSTRUCT) { static inline void freestruct_nsec3param(ARGS_FREESTRUCT) { - dns_rdata_nsec3param_t *nsec3param = source; + dns_rdata_nsec3param_t *nsec3param; + + REQUIRE(((dns_rdata_nsec3param_t *)source) != NULL); + REQUIRE(((dns_rdata_nsec3param_t *)source)->common.rdtype == + dns_rdatatype_nsec3param); - REQUIRE(nsec3param != NULL); - REQUIRE(nsec3param->common.rdtype == dns_rdatatype_nsec3param); + nsec3param = source; if (nsec3param->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/nsec_47.c b/lib/dns/rdata/generic/nsec_47.c index 824d5d3b452..3cbbd0f3e40 100644 --- a/lib/dns/rdata/generic/nsec_47.c +++ b/lib/dns/rdata/generic/nsec_47.c @@ -131,14 +131,17 @@ compare_nsec(ARGS_COMPARE) { static inline isc_result_t fromstruct_nsec(ARGS_FROMSTRUCT) { - dns_rdata_nsec_t *nsec = source; + dns_rdata_nsec_t *nsec; isc_region_t region; REQUIRE(type == dns_rdatatype_nsec); - REQUIRE(nsec != NULL); - REQUIRE(nsec->common.rdtype == type); - REQUIRE(nsec->common.rdclass == rdclass); - REQUIRE(nsec->typebits != NULL || nsec->len == 0); + REQUIRE(((dns_rdata_nsec_t *)source) != NULL); + REQUIRE(((dns_rdata_nsec_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_nsec_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_nsec_t *)source)->typebits != NULL || + ((dns_rdata_nsec_t *)source)->len == 0); + + nsec = source; UNUSED(type); UNUSED(rdclass); @@ -155,13 +158,15 @@ fromstruct_nsec(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_nsec(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_nsec_t *nsec = target; + dns_rdata_nsec_t *nsec; dns_name_t name; + REQUIRE(((dns_rdata_nsec_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_nsec); - REQUIRE(nsec != NULL); REQUIRE(rdata->length != 0); + nsec = target; + nsec->common.rdclass = rdata->rdclass; nsec->common.rdtype = rdata->type; ISC_LINK_INIT(&nsec->common, link); @@ -189,10 +194,13 @@ tostruct_nsec(ARGS_TOSTRUCT) { static inline void freestruct_nsec(ARGS_FREESTRUCT) { - dns_rdata_nsec_t *nsec = source; + dns_rdata_nsec_t *nsec; + + REQUIRE(((dns_rdata_nsec_t *)source) != NULL); + REQUIRE(((dns_rdata_nsec_t *)source)->common.rdtype == + dns_rdatatype_nsec); - REQUIRE(nsec != NULL); - REQUIRE(nsec->common.rdtype == dns_rdatatype_nsec); + nsec = source; if (nsec->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/null_10.c b/lib/dns/rdata/generic/null_10.c index 5ffdb71e116..419297b7c7b 100644 --- a/lib/dns/rdata/generic/null_10.c +++ b/lib/dns/rdata/generic/null_10.c @@ -77,13 +77,16 @@ compare_null(ARGS_COMPARE) { static inline isc_result_t fromstruct_null(ARGS_FROMSTRUCT) { - dns_rdata_null_t *null = source; + dns_rdata_null_t *null; REQUIRE(type == dns_rdatatype_null); - REQUIRE(null != NULL); - REQUIRE(null->common.rdtype == type); - REQUIRE(null->common.rdclass == rdclass); - REQUIRE(null->data != NULL || null->length == 0); + REQUIRE(((dns_rdata_null_t *)source) != NULL); + REQUIRE(((dns_rdata_null_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_null_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_null_t *)source)->data != NULL || + ((dns_rdata_null_t *)source)->length == 0); + + null = source; UNUSED(type); UNUSED(rdclass); @@ -93,11 +96,13 @@ fromstruct_null(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_null(ARGS_TOSTRUCT) { - dns_rdata_null_t *null = target; + dns_rdata_null_t *null; isc_region_t r; REQUIRE(rdata->type == dns_rdatatype_null); - REQUIRE(null != NULL); + REQUIRE(((dns_rdata_null_t *)target) != NULL); + + null = target; null->common.rdclass = rdata->rdclass; null->common.rdtype = rdata->type; @@ -115,10 +120,13 @@ tostruct_null(ARGS_TOSTRUCT) { static inline void freestruct_null(ARGS_FREESTRUCT) { - dns_rdata_null_t *null = source; + dns_rdata_null_t *null; + + REQUIRE(((dns_rdata_null_t *)source) != NULL); + REQUIRE(((dns_rdata_null_t *)source)->common.rdtype == + dns_rdatatype_null); - REQUIRE(null != NULL); - REQUIRE(null->common.rdtype == dns_rdatatype_null); + null = source; if (null->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/nxt_30.c b/lib/dns/rdata/generic/nxt_30.c index ba8c87bb24d..c71f92622ee 100644 --- a/lib/dns/rdata/generic/nxt_30.c +++ b/lib/dns/rdata/generic/nxt_30.c @@ -193,14 +193,18 @@ compare_nxt(ARGS_COMPARE) { static inline isc_result_t fromstruct_nxt(ARGS_FROMSTRUCT) { - dns_rdata_nxt_t *nxt = source; + dns_rdata_nxt_t *nxt; isc_region_t region; REQUIRE(type == dns_rdatatype_nxt); - REQUIRE(nxt != NULL); - REQUIRE(nxt->common.rdtype == type); - REQUIRE(nxt->common.rdclass == rdclass); - REQUIRE(nxt->typebits != NULL || nxt->len == 0); + REQUIRE(((dns_rdata_nxt_t *)source) != NULL); + REQUIRE(((dns_rdata_nxt_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_nxt_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_nxt_t *)source)->typebits != NULL || + ((dns_rdata_nxt_t *)source)->len == 0); + + nxt = source; + if (nxt->typebits != NULL && (nxt->typebits[0] & 0x80) == 0) { REQUIRE(nxt->len <= 16); REQUIRE(nxt->typebits[nxt->len - 1] != 0); @@ -218,13 +222,15 @@ fromstruct_nxt(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_nxt(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_nxt_t *nxt = target; + dns_rdata_nxt_t *nxt; dns_name_t name; + REQUIRE(((dns_rdata_nxt_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_nxt); - REQUIRE(nxt != NULL); REQUIRE(rdata->length != 0); + nxt = target; + nxt->common.rdclass = rdata->rdclass; nxt->common.rdtype = rdata->type; ISC_LINK_INIT(&nxt->common, link); @@ -252,10 +258,13 @@ tostruct_nxt(ARGS_TOSTRUCT) { static inline void freestruct_nxt(ARGS_FREESTRUCT) { - dns_rdata_nxt_t *nxt = source; + dns_rdata_nxt_t *nxt; + + REQUIRE(((dns_rdata_nxt_t *)source) != NULL); + REQUIRE(((dns_rdata_nxt_t *)source)->common.rdtype == + dns_rdatatype_nxt); - REQUIRE(nxt != NULL); - REQUIRE(nxt->common.rdtype == dns_rdatatype_nxt); + nxt = source; if (nxt->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/openpgpkey_61.c b/lib/dns/rdata/generic/openpgpkey_61.c index 900d665c2e6..a9dd617b22e 100644 --- a/lib/dns/rdata/generic/openpgpkey_61.c +++ b/lib/dns/rdata/generic/openpgpkey_61.c @@ -113,13 +113,16 @@ compare_openpgpkey(ARGS_COMPARE) { static inline isc_result_t fromstruct_openpgpkey(ARGS_FROMSTRUCT) { - dns_rdata_openpgpkey_t *sig = source; + dns_rdata_openpgpkey_t *sig; REQUIRE(type == dns_rdatatype_openpgpkey); - REQUIRE(sig != NULL); - REQUIRE(sig->common.rdtype == type); - REQUIRE(sig->common.rdclass == rdclass); - REQUIRE(sig->keyring != NULL && sig->length != 0); + REQUIRE(((dns_rdata_openpgpkey_t *)source) != NULL); + REQUIRE(((dns_rdata_openpgpkey_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_openpgpkey_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_openpgpkey_t *)source)->keyring != NULL); + REQUIRE(((dns_rdata_openpgpkey_t *)source)->length != 0); + + sig = source; UNUSED(type); UNUSED(rdclass); @@ -133,12 +136,14 @@ fromstruct_openpgpkey(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_openpgpkey(ARGS_TOSTRUCT) { isc_region_t sr; - dns_rdata_openpgpkey_t *sig = target; + dns_rdata_openpgpkey_t *sig; + REQUIRE(((dns_rdata_openpgpkey_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_openpgpkey); - REQUIRE(sig != NULL); REQUIRE(rdata->length != 0); + sig = target; + sig->common.rdclass = rdata->rdclass; sig->common.rdtype = rdata->type; ISC_LINK_INIT(&sig->common, link); @@ -162,10 +167,13 @@ tostruct_openpgpkey(ARGS_TOSTRUCT) { static inline void freestruct_openpgpkey(ARGS_FREESTRUCT) { - dns_rdata_openpgpkey_t *sig = (dns_rdata_openpgpkey_t *) source; + dns_rdata_openpgpkey_t *sig; + + REQUIRE(((dns_rdata_openpgpkey_t *)source) != NULL); + REQUIRE(((dns_rdata_openpgpkey_t *)source)->common.rdtype == + dns_rdatatype_openpgpkey); - REQUIRE(sig != NULL); - REQUIRE(sig->common.rdtype == dns_rdatatype_openpgpkey); + sig = (dns_rdata_openpgpkey_t *) source; if (sig->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/opt_41.c b/lib/dns/rdata/generic/opt_41.c index d361e13a3a8..15f6299a1fa 100644 --- a/lib/dns/rdata/generic/opt_41.c +++ b/lib/dns/rdata/generic/opt_41.c @@ -255,15 +255,18 @@ compare_opt(ARGS_COMPARE) { static inline isc_result_t fromstruct_opt(ARGS_FROMSTRUCT) { - dns_rdata_opt_t *opt = source; + dns_rdata_opt_t *opt; isc_region_t region; uint16_t length; REQUIRE(type == dns_rdatatype_opt); - REQUIRE(opt != NULL); - REQUIRE(opt->common.rdtype == type); - REQUIRE(opt->common.rdclass == rdclass); - REQUIRE(opt->options != NULL || opt->length == 0); + REQUIRE(((dns_rdata_opt_t *)source) != NULL); + REQUIRE(((dns_rdata_opt_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_opt_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_opt_t *)source)->options != NULL || + ((dns_rdata_opt_t *)source)->length == 0); + + opt = source; UNUSED(type); UNUSED(rdclass); @@ -286,11 +289,13 @@ fromstruct_opt(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_opt(ARGS_TOSTRUCT) { - dns_rdata_opt_t *opt = target; + dns_rdata_opt_t *opt; isc_region_t r; REQUIRE(rdata->type == dns_rdatatype_opt); - REQUIRE(opt != NULL); + REQUIRE(((dns_rdata_opt_t *)target) != NULL); + + opt = target; opt->common.rdclass = rdata->rdclass; opt->common.rdtype = rdata->type; @@ -309,10 +314,13 @@ tostruct_opt(ARGS_TOSTRUCT) { static inline void freestruct_opt(ARGS_FREESTRUCT) { - dns_rdata_opt_t *opt = source; + dns_rdata_opt_t *opt; - REQUIRE(opt != NULL); - REQUIRE(opt->common.rdtype == dns_rdatatype_opt); + REQUIRE(((dns_rdata_opt_t *)source) != NULL); + REQUIRE(((dns_rdata_opt_t *)source)->common.rdtype == + dns_rdatatype_opt); + + opt = source; if (opt->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/ptr_12.c b/lib/dns/rdata/generic/ptr_12.c index 1e405152ba8..b2b579563e4 100644 --- a/lib/dns/rdata/generic/ptr_12.c +++ b/lib/dns/rdata/generic/ptr_12.c @@ -128,13 +128,15 @@ compare_ptr(ARGS_COMPARE) { static inline isc_result_t fromstruct_ptr(ARGS_FROMSTRUCT) { - dns_rdata_ptr_t *ptr = source; + dns_rdata_ptr_t *ptr; isc_region_t region; REQUIRE(type == dns_rdatatype_ptr); - REQUIRE(ptr != NULL); - REQUIRE(ptr->common.rdtype == type); - REQUIRE(ptr->common.rdclass == rdclass); + REQUIRE(((dns_rdata_ptr_t *)source) != NULL); + REQUIRE(((dns_rdata_ptr_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_ptr_t *)source)->common.rdclass == rdclass); + + ptr = source; UNUSED(type); UNUSED(rdclass); @@ -146,13 +148,15 @@ fromstruct_ptr(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_ptr(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_ptr_t *ptr = target; + dns_rdata_ptr_t *ptr; dns_name_t name; + REQUIRE(((dns_rdata_ptr_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_ptr); - REQUIRE(ptr != NULL); REQUIRE(rdata->length != 0); + ptr = target; + ptr->common.rdclass = rdata->rdclass; ptr->common.rdtype = rdata->type; ISC_LINK_INIT(&ptr->common, link); @@ -168,10 +172,13 @@ tostruct_ptr(ARGS_TOSTRUCT) { static inline void freestruct_ptr(ARGS_FREESTRUCT) { - dns_rdata_ptr_t *ptr = source; + dns_rdata_ptr_t *ptr; + + REQUIRE(((dns_rdata_ptr_t *)source) != NULL); + REQUIRE(((dns_rdata_ptr_t *)source)->common.rdtype == + dns_rdatatype_ptr); - REQUIRE(ptr != NULL); - REQUIRE(ptr->common.rdtype == dns_rdatatype_ptr); + ptr = source; if (ptr->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/rkey_57.c b/lib/dns/rdata/generic/rkey_57.c index 2475a48fac3..2a0073c00ab 100644 --- a/lib/dns/rdata/generic/rkey_57.c +++ b/lib/dns/rdata/generic/rkey_57.c @@ -83,12 +83,14 @@ fromstruct_rkey(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_rkey(ARGS_TOSTRUCT) { - dns_rdata_rkey_t *rkey = target; + dns_rdata_rkey_t *rkey; - REQUIRE(rkey != NULL); + REQUIRE(((dns_rdata_rkey_t *)target) != NULL); REQUIRE(rdata != NULL); REQUIRE(rdata->type == dns_rdatatype_rkey); + rkey = target; + rkey->common.rdclass = rdata->rdclass; rkey->common.rdtype = rdata->type; ISC_LINK_INIT(&rkey->common, link); @@ -98,10 +100,9 @@ tostruct_rkey(ARGS_TOSTRUCT) { static inline void freestruct_rkey(ARGS_FREESTRUCT) { - dns_rdata_rkey_t *rkey = (dns_rdata_rkey_t *) source; - - REQUIRE(rkey != NULL); - REQUIRE(rkey->common.rdtype == dns_rdatatype_rkey); + REQUIRE(((dns_rdata_rkey_t *)source) != NULL); + REQUIRE(((dns_rdata_rkey_t *)source)->common.rdtype == + dns_rdatatype_rkey); generic_freestruct_key(source); } diff --git a/lib/dns/rdata/generic/rp_17.c b/lib/dns/rdata/generic/rp_17.c index ee2eef22fdb..8ec18b56586 100644 --- a/lib/dns/rdata/generic/rp_17.c +++ b/lib/dns/rdata/generic/rp_17.c @@ -173,13 +173,15 @@ compare_rp(ARGS_COMPARE) { static inline isc_result_t fromstruct_rp(ARGS_FROMSTRUCT) { - dns_rdata_rp_t *rp = source; + dns_rdata_rp_t *rp; isc_region_t region; REQUIRE(type == dns_rdatatype_rp); - REQUIRE(rp != NULL); - REQUIRE(rp->common.rdtype == type); - REQUIRE(rp->common.rdclass == rdclass); + REQUIRE(((dns_rdata_rp_t *)source) != NULL); + REQUIRE(((dns_rdata_rp_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_rp_t *)source)->common.rdclass == rdclass); + + rp = source; UNUSED(type); UNUSED(rdclass); @@ -194,13 +196,15 @@ static inline isc_result_t tostruct_rp(ARGS_TOSTRUCT) { isc_result_t result; isc_region_t region; - dns_rdata_rp_t *rp = target; + dns_rdata_rp_t *rp; dns_name_t name; + REQUIRE(((dns_rdata_rp_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_rp); - REQUIRE(rp != NULL); REQUIRE(rdata->length != 0); + rp = target; + rp->common.rdclass = rdata->rdclass; rp->common.rdtype = rdata->type; ISC_LINK_INIT(&rp->common, link); @@ -228,10 +232,12 @@ tostruct_rp(ARGS_TOSTRUCT) { static inline void freestruct_rp(ARGS_FREESTRUCT) { - dns_rdata_rp_t *rp = source; + dns_rdata_rp_t *rp; + + REQUIRE(((dns_rdata_rp_t *)source) != NULL); + REQUIRE(((dns_rdata_rp_t *)source)->common.rdtype == dns_rdatatype_rp); - REQUIRE(rp != NULL); - REQUIRE(rp->common.rdtype == dns_rdatatype_rp); + rp = source; if (rp->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/rrsig_46.c b/lib/dns/rdata/generic/rrsig_46.c index 975810f2654..f7aa66e3725 100644 --- a/lib/dns/rdata/generic/rrsig_46.c +++ b/lib/dns/rdata/generic/rrsig_46.c @@ -353,13 +353,16 @@ compare_rrsig(ARGS_COMPARE) { static inline isc_result_t fromstruct_rrsig(ARGS_FROMSTRUCT) { - dns_rdata_rrsig_t *sig = source; + dns_rdata_rrsig_t *sig; REQUIRE(type == dns_rdatatype_rrsig); - REQUIRE(sig != NULL); - REQUIRE(sig->common.rdtype == type); - REQUIRE(sig->common.rdclass == rdclass); - REQUIRE(sig->signature != NULL || sig->siglen == 0); + REQUIRE(((dns_rdata_rrsig_t *)source) != NULL); + REQUIRE(((dns_rdata_rrsig_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_rrsig_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_rrsig_t *)source)->signature != NULL || + ((dns_rdata_rrsig_t *)source)->siglen == 0); + + sig = source; UNUSED(type); UNUSED(rdclass); @@ -413,13 +416,15 @@ fromstruct_rrsig(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_rrsig(ARGS_TOSTRUCT) { isc_region_t sr; - dns_rdata_rrsig_t *sig = target; + dns_rdata_rrsig_t *sig; dns_name_t signer; + REQUIRE(((dns_rdata_rrsig_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_rrsig); - REQUIRE(sig != NULL); REQUIRE(rdata->length != 0); + sig = target; + sig->common.rdclass = rdata->rdclass; sig->common.rdtype = rdata->type; ISC_LINK_INIT(&sig->common, link); @@ -494,10 +499,13 @@ tostruct_rrsig(ARGS_TOSTRUCT) { static inline void freestruct_rrsig(ARGS_FREESTRUCT) { - dns_rdata_rrsig_t *sig = (dns_rdata_rrsig_t *) source; + dns_rdata_rrsig_t *sig; + + REQUIRE(((dns_rdata_rrsig_t *)source) != NULL); + REQUIRE(((dns_rdata_rrsig_t *)source)->common.rdtype == + dns_rdatatype_rrsig); - REQUIRE(sig != NULL); - REQUIRE(sig->common.rdtype == dns_rdatatype_rrsig); + sig = (dns_rdata_rrsig_t *) source; if (sig->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/rt_21.c b/lib/dns/rdata/generic/rt_21.c index 43c08628f8e..47d9640f9ad 100644 --- a/lib/dns/rdata/generic/rt_21.c +++ b/lib/dns/rdata/generic/rt_21.c @@ -166,13 +166,15 @@ compare_rt(ARGS_COMPARE) { static inline isc_result_t fromstruct_rt(ARGS_FROMSTRUCT) { - dns_rdata_rt_t *rt = source; + dns_rdata_rt_t *rt; isc_region_t region; REQUIRE(type == dns_rdatatype_rt); - REQUIRE(rt != NULL); - REQUIRE(rt->common.rdtype == type); - REQUIRE(rt->common.rdclass == rdclass); + REQUIRE(((dns_rdata_rt_t *)source) != NULL); + REQUIRE(((dns_rdata_rt_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_rt_t *)source)->common.rdclass == rdclass); + + rt = source; UNUSED(type); UNUSED(rdclass); @@ -185,13 +187,15 @@ fromstruct_rt(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_rt(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_rt_t *rt = target; + dns_rdata_rt_t *rt; dns_name_t name; + REQUIRE(((dns_rdata_rt_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_rt); - REQUIRE(rt != NULL); REQUIRE(rdata->length != 0); + rt = target; + rt->common.rdclass = rdata->rdclass; rt->common.rdtype = rdata->type; ISC_LINK_INIT(&rt->common, link); @@ -210,10 +214,12 @@ tostruct_rt(ARGS_TOSTRUCT) { static inline void freestruct_rt(ARGS_FREESTRUCT) { - dns_rdata_rt_t *rt = source; + dns_rdata_rt_t *rt; + + REQUIRE(((dns_rdata_rt_t *)source) != NULL); + REQUIRE(((dns_rdata_rt_t *)source)->common.rdtype == dns_rdatatype_rt); - REQUIRE(rt != NULL); - REQUIRE(rt->common.rdtype == dns_rdatatype_rt); + rt = source; if (rt->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/sig_24.c b/lib/dns/rdata/generic/sig_24.c index 47a69e86337..a2cf1cee68d 100644 --- a/lib/dns/rdata/generic/sig_24.c +++ b/lib/dns/rdata/generic/sig_24.c @@ -352,13 +352,16 @@ compare_sig(ARGS_COMPARE) { static inline isc_result_t fromstruct_sig(ARGS_FROMSTRUCT) { - dns_rdata_sig_t *sig = source; + dns_rdata_sig_t *sig; REQUIRE(type == dns_rdatatype_sig); - REQUIRE(sig != NULL); - REQUIRE(sig->common.rdtype == type); - REQUIRE(sig->common.rdclass == rdclass); - REQUIRE(sig->signature != NULL || sig->siglen == 0); + REQUIRE(((dns_rdata_sig_t *)source) != NULL); + REQUIRE(((dns_rdata_sig_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_sig_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_sig_t *)source)->signature != NULL || + ((dns_rdata_sig_t *)source)->siglen == 0); + + sig = source; UNUSED(type); UNUSED(rdclass); @@ -412,13 +415,15 @@ fromstruct_sig(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_sig(ARGS_TOSTRUCT) { isc_region_t sr; - dns_rdata_sig_t *sig = target; + dns_rdata_sig_t *sig; dns_name_t signer; + REQUIRE(((dns_rdata_sig_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_sig); - REQUIRE(sig != NULL); REQUIRE(rdata->length != 0); + sig = target; + sig->common.rdclass = rdata->rdclass; sig->common.rdtype = rdata->type; ISC_LINK_INIT(&sig->common, link); @@ -493,10 +498,13 @@ tostruct_sig(ARGS_TOSTRUCT) { static inline void freestruct_sig(ARGS_FREESTRUCT) { - dns_rdata_sig_t *sig = (dns_rdata_sig_t *) source; + dns_rdata_sig_t *sig; + + REQUIRE(((dns_rdata_sig_t *)source) != NULL); + REQUIRE(((dns_rdata_sig_t *)source)->common.rdtype == + dns_rdatatype_sig); - REQUIRE(sig != NULL); - REQUIRE(sig->common.rdtype == dns_rdatatype_sig); + sig = (dns_rdata_sig_t *) source; if (sig->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/sink_40.c b/lib/dns/rdata/generic/sink_40.c index 13f8562d8c3..07b24bd2a62 100644 --- a/lib/dns/rdata/generic/sink_40.c +++ b/lib/dns/rdata/generic/sink_40.c @@ -143,12 +143,14 @@ compare_sink(ARGS_COMPARE) { static inline isc_result_t fromstruct_sink(ARGS_FROMSTRUCT) { - dns_rdata_sink_t *sink = source; + dns_rdata_sink_t *sink; REQUIRE(type == dns_rdatatype_sink); - REQUIRE(sink != NULL); - REQUIRE(sink->common.rdtype == type); - REQUIRE(sink->common.rdclass == rdclass); + REQUIRE(((dns_rdata_sink_t *)source) != NULL); + REQUIRE(((dns_rdata_sink_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_sink_t *)source)->common.rdclass == rdclass); + + sink = source; UNUSED(type); UNUSED(rdclass); @@ -168,13 +170,15 @@ fromstruct_sink(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_sink(ARGS_TOSTRUCT) { - dns_rdata_sink_t *sink = target; + dns_rdata_sink_t *sink; isc_region_t sr; + REQUIRE(((dns_rdata_sink_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_sink); - REQUIRE(sink != NULL); REQUIRE(rdata->length >= 3); + sink = target; + sink->common.rdclass = rdata->rdclass; sink->common.rdtype = rdata->type; ISC_LINK_INIT(&sink->common, link); @@ -211,10 +215,13 @@ tostruct_sink(ARGS_TOSTRUCT) { static inline void freestruct_sink(ARGS_FREESTRUCT) { - dns_rdata_sink_t *sink = (dns_rdata_sink_t *) source; + dns_rdata_sink_t *sink; + + REQUIRE(((dns_rdata_sink_t *)source) != NULL); + REQUIRE(((dns_rdata_sink_t *)source)->common.rdtype == + dns_rdatatype_sink); - REQUIRE(sink != NULL); - REQUIRE(sink->common.rdtype == dns_rdatatype_sink); + sink = (dns_rdata_sink_t *) source; if (sink->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/smimea_53.c b/lib/dns/rdata/generic/smimea_53.c index 152ad9cfa0f..a44b3fe5d52 100644 --- a/lib/dns/rdata/generic/smimea_53.c +++ b/lib/dns/rdata/generic/smimea_53.c @@ -79,11 +79,13 @@ fromstruct_smimea(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_smimea(ARGS_TOSTRUCT) { - dns_rdata_smimea_t *smimea = target; + dns_rdata_smimea_t *smimea; REQUIRE(rdata != NULL); REQUIRE(rdata->type == dns_rdatatype_smimea); - REQUIRE(smimea != NULL); + REQUIRE(((dns_rdata_smimea_t *)target) != NULL); + + smimea = target; smimea->common.rdclass = rdata->rdclass; smimea->common.rdtype = rdata->type; @@ -94,10 +96,9 @@ tostruct_smimea(ARGS_TOSTRUCT) { static inline void freestruct_smimea(ARGS_FREESTRUCT) { - dns_rdata_smimea_t *smimea = source; - - REQUIRE(smimea != NULL); - REQUIRE(smimea->common.rdtype == dns_rdatatype_smimea); + REQUIRE(((dns_rdata_smimea_t *)source) != NULL); + REQUIRE(((dns_rdata_smimea_t *)source)->common.rdtype == + dns_rdatatype_smimea); generic_freestruct_tlsa(source); } diff --git a/lib/dns/rdata/generic/soa_6.c b/lib/dns/rdata/generic/soa_6.c index 288366eaf8f..2e65fe8880e 100644 --- a/lib/dns/rdata/generic/soa_6.c +++ b/lib/dns/rdata/generic/soa_6.c @@ -268,13 +268,15 @@ compare_soa(ARGS_COMPARE) { static inline isc_result_t fromstruct_soa(ARGS_FROMSTRUCT) { - dns_rdata_soa_t *soa = source; + dns_rdata_soa_t *soa; isc_region_t region; REQUIRE(type == dns_rdatatype_soa); - REQUIRE(soa != NULL); - REQUIRE(soa->common.rdtype == type); - REQUIRE(soa->common.rdclass == rdclass); + REQUIRE(((dns_rdata_soa_t *)source) != NULL); + REQUIRE(((dns_rdata_soa_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_soa_t *)source)->common.rdclass == rdclass); + + soa = source; UNUSED(type); UNUSED(rdclass); @@ -293,14 +295,16 @@ fromstruct_soa(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_soa(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_soa_t *soa = target; + dns_rdata_soa_t *soa; dns_name_t name; isc_result_t result; + REQUIRE(((dns_rdata_soa_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_soa); - REQUIRE(soa != NULL); REQUIRE(rdata->length != 0); + soa = target; + soa->common.rdclass = rdata->rdclass; soa->common.rdtype = rdata->type; ISC_LINK_INIT(&soa->common, link); @@ -346,10 +350,13 @@ tostruct_soa(ARGS_TOSTRUCT) { static inline void freestruct_soa(ARGS_FREESTRUCT) { - dns_rdata_soa_t *soa = source; + dns_rdata_soa_t *soa; + + REQUIRE(((dns_rdata_soa_t *)source) != NULL); + REQUIRE(((dns_rdata_soa_t *)source)->common.rdtype == + dns_rdatatype_soa); - REQUIRE(soa != NULL); - REQUIRE(soa->common.rdtype == dns_rdatatype_soa); + soa = source; if (soa->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/spf_99.c b/lib/dns/rdata/generic/spf_99.c index 3668d9c76f2..778563d7429 100644 --- a/lib/dns/rdata/generic/spf_99.c +++ b/lib/dns/rdata/generic/spf_99.c @@ -87,12 +87,14 @@ fromstruct_spf(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_spf(ARGS_TOSTRUCT) { - dns_rdata_spf_t *spf = target; + dns_rdata_spf_t *spf; - REQUIRE(spf != NULL); + REQUIRE(((dns_rdata_spf_t *)target) != NULL); REQUIRE(rdata != NULL); REQUIRE(rdata->type == dns_rdatatype_spf); + spf = target; + spf->common.rdclass = rdata->rdclass; spf->common.rdtype = rdata->type; ISC_LINK_INIT(&spf->common, link); @@ -102,10 +104,9 @@ tostruct_spf(ARGS_TOSTRUCT) { static inline void freestruct_spf(ARGS_FREESTRUCT) { - dns_rdata_spf_t *spf = source; - - REQUIRE(spf != NULL); - REQUIRE(spf->common.rdtype == dns_rdatatype_spf); + REQUIRE(((dns_rdata_spf_t *)source) != NULL); + REQUIRE(((dns_rdata_spf_t *)source)->common.rdtype == + dns_rdatatype_spf); generic_freestruct_txt(source); } diff --git a/lib/dns/rdata/generic/sshfp_44.c b/lib/dns/rdata/generic/sshfp_44.c index 853416eb944..4c311e34582 100644 --- a/lib/dns/rdata/generic/sshfp_44.c +++ b/lib/dns/rdata/generic/sshfp_44.c @@ -173,12 +173,14 @@ compare_sshfp(ARGS_COMPARE) { static inline isc_result_t fromstruct_sshfp(ARGS_FROMSTRUCT) { - dns_rdata_sshfp_t *sshfp = source; + dns_rdata_sshfp_t *sshfp; REQUIRE(type == dns_rdatatype_sshfp); - REQUIRE(sshfp != NULL); - REQUIRE(sshfp->common.rdtype == type); - REQUIRE(sshfp->common.rdclass == rdclass); + REQUIRE(((dns_rdata_sshfp_t *)source) != NULL); + REQUIRE(((dns_rdata_sshfp_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_sshfp_t *)source)->common.rdclass == rdclass); + + sshfp = source; UNUSED(type); UNUSED(rdclass); @@ -191,13 +193,15 @@ fromstruct_sshfp(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_sshfp(ARGS_TOSTRUCT) { - dns_rdata_sshfp_t *sshfp = target; + dns_rdata_sshfp_t *sshfp; isc_region_t region; + REQUIRE(((dns_rdata_sshfp_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_sshfp); - REQUIRE(sshfp != NULL); REQUIRE(rdata->length != 0); + sshfp = target; + sshfp->common.rdclass = rdata->rdclass; sshfp->common.rdtype = rdata->type; ISC_LINK_INIT(&sshfp->common, link); @@ -220,10 +224,13 @@ tostruct_sshfp(ARGS_TOSTRUCT) { static inline void freestruct_sshfp(ARGS_FREESTRUCT) { - dns_rdata_sshfp_t *sshfp = source; + dns_rdata_sshfp_t *sshfp; + + REQUIRE(((dns_rdata_sshfp_t *)source) != NULL); + REQUIRE(((dns_rdata_sshfp_t *)source)->common.rdtype == + dns_rdatatype_sshfp); - REQUIRE(sshfp != NULL); - REQUIRE(sshfp->common.rdtype == dns_rdatatype_sshfp); + sshfp = source; if (sshfp->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/ta_32768.c b/lib/dns/rdata/generic/ta_32768.c index 0a38619a48e..451a4fdde3e 100644 --- a/lib/dns/rdata/generic/ta_32768.c +++ b/lib/dns/rdata/generic/ta_32768.c @@ -81,10 +81,12 @@ fromstruct_ta(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_ta(ARGS_TOSTRUCT) { - dns_rdata_ds_t *ds = target; + dns_rdata_ds_t *ds; REQUIRE(rdata->type == dns_rdatatype_ta); - REQUIRE(ds != NULL); + REQUIRE(((dns_rdata_ds_t *)target) != NULL); + + ds = target; /* * Checked by generic_tostruct_ds(). @@ -98,10 +100,12 @@ tostruct_ta(ARGS_TOSTRUCT) { static inline void freestruct_ta(ARGS_FREESTRUCT) { - dns_rdata_ta_t *ds = source; + dns_rdata_ta_t *ds; + + REQUIRE(((dns_rdata_ds_t *)source) != NULL); + REQUIRE(((dns_rdata_ds_t *)source)->common.rdtype == dns_rdatatype_ta); - REQUIRE(ds != NULL); - REQUIRE(ds->common.rdtype == dns_rdatatype_ta); + ds = source; if (ds->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/talink_58.c b/lib/dns/rdata/generic/talink_58.c index f286982aa7d..157df1a8dd8 100644 --- a/lib/dns/rdata/generic/talink_58.c +++ b/lib/dns/rdata/generic/talink_58.c @@ -140,13 +140,15 @@ compare_talink(ARGS_COMPARE) { static inline isc_result_t fromstruct_talink(ARGS_FROMSTRUCT) { - dns_rdata_talink_t *talink = source; + dns_rdata_talink_t *talink; isc_region_t region; REQUIRE(type == dns_rdatatype_talink); - REQUIRE(talink != NULL); - REQUIRE(talink->common.rdtype == type); - REQUIRE(talink->common.rdclass == rdclass); + REQUIRE(((dns_rdata_talink_t *)source) != NULL); + REQUIRE(((dns_rdata_talink_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_talink_t *)source)->common.rdclass == rdclass); + + talink = source; UNUSED(type); UNUSED(rdclass); @@ -160,14 +162,16 @@ fromstruct_talink(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_talink(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_talink_t *talink = target; + dns_rdata_talink_t *talink; dns_name_t name; isc_result_t result; + REQUIRE(((dns_rdata_talink_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_talink); - REQUIRE(talink != NULL); REQUIRE(rdata->length != 0); + talink = target; + talink->common.rdclass = rdata->rdclass; talink->common.rdtype = rdata->type; ISC_LINK_INIT(&talink->common, link); @@ -198,10 +202,13 @@ tostruct_talink(ARGS_TOSTRUCT) { static inline void freestruct_talink(ARGS_FREESTRUCT) { - dns_rdata_talink_t *talink = source; + dns_rdata_talink_t *talink; + + REQUIRE(((dns_rdata_talink_t *)source) != NULL); + REQUIRE(((dns_rdata_talink_t *)source)->common.rdtype == + dns_rdatatype_talink); - REQUIRE(talink != NULL); - REQUIRE(talink->common.rdtype == dns_rdatatype_talink); + talink = source; if (talink->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/tkey_249.c b/lib/dns/rdata/generic/tkey_249.c index 3a05f9e04e5..47d5777c32e 100644 --- a/lib/dns/rdata/generic/tkey_249.c +++ b/lib/dns/rdata/generic/tkey_249.c @@ -340,12 +340,14 @@ compare_tkey(ARGS_COMPARE) { static inline isc_result_t fromstruct_tkey(ARGS_FROMSTRUCT) { - dns_rdata_tkey_t *tkey = source; + dns_rdata_tkey_t *tkey; REQUIRE(type == dns_rdatatype_tkey); - REQUIRE(tkey != NULL); - REQUIRE(tkey->common.rdtype == type); - REQUIRE(tkey->common.rdclass == rdclass); + REQUIRE(((dns_rdata_tkey_t *)source) != NULL); + REQUIRE(((dns_rdata_tkey_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_tkey_t *)source)->common.rdclass == rdclass); + + tkey = source; UNUSED(type); UNUSED(rdclass); @@ -398,14 +400,16 @@ fromstruct_tkey(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_tkey(ARGS_TOSTRUCT) { - dns_rdata_tkey_t *tkey = target; + dns_rdata_tkey_t *tkey; dns_name_t alg; isc_region_t sr; + REQUIRE(((dns_rdata_tkey_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_tkey); - REQUIRE(tkey != NULL); REQUIRE(rdata->length != 0); + tkey = target; + tkey->common.rdclass = rdata->rdclass; tkey->common.rdtype = rdata->type; ISC_LINK_INIT(&tkey->common, link); @@ -487,9 +491,11 @@ tostruct_tkey(ARGS_TOSTRUCT) { static inline void freestruct_tkey(ARGS_FREESTRUCT) { - dns_rdata_tkey_t *tkey = (dns_rdata_tkey_t *) source; + dns_rdata_tkey_t *tkey; + + REQUIRE(((dns_rdata_tkey_t *)source) != NULL); - REQUIRE(tkey != NULL); + tkey = (dns_rdata_tkey_t *) source; if (tkey->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/tlsa_52.c b/lib/dns/rdata/generic/tlsa_52.c index 1eeb8d263df..cb8b57a7429 100644 --- a/lib/dns/rdata/generic/tlsa_52.c +++ b/lib/dns/rdata/generic/tlsa_52.c @@ -186,11 +186,13 @@ compare_tlsa(ARGS_COMPARE) { static inline isc_result_t generic_fromstruct_tlsa(ARGS_FROMSTRUCT) { - dns_rdata_tlsa_t *tlsa = source; + dns_rdata_tlsa_t *tlsa; - REQUIRE(tlsa != NULL); - REQUIRE(tlsa->common.rdtype == type); - REQUIRE(tlsa->common.rdclass == rdclass); + REQUIRE(((dns_rdata_tlsa_t *)source) != NULL); + REQUIRE(((dns_rdata_tlsa_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_tlsa_t *)source)->common.rdclass == rdclass); + + tlsa = source; UNUSED(type); UNUSED(rdclass); @@ -204,16 +206,16 @@ generic_fromstruct_tlsa(ARGS_FROMSTRUCT) { static inline isc_result_t generic_tostruct_tlsa(ARGS_TOSTRUCT) { - dns_rdata_tlsa_t *tlsa = target; + dns_rdata_tlsa_t *tlsa; isc_region_t region; - REQUIRE(tlsa != NULL); REQUIRE(rdata->length != 0); + REQUIRE(((dns_rdata_tlsa_t *)target) != NULL); + REQUIRE(((dns_rdata_tlsa_t *)target)->common.rdclass == rdata->rdclass); + REQUIRE(((dns_rdata_tlsa_t *)target)->common.rdtype == rdata->type); + REQUIRE(!ISC_LINK_LINKED(&((dns_rdata_tlsa_t *)target)->common, link)); - REQUIRE(tlsa != NULL); - REQUIRE(tlsa->common.rdclass == rdata->rdclass); - REQUIRE(tlsa->common.rdtype == rdata->type); - REQUIRE(!ISC_LINK_LINKED(&tlsa->common, link)); + tlsa = target; dns_rdata_toregion(rdata, ®ion); @@ -235,9 +237,11 @@ generic_tostruct_tlsa(ARGS_TOSTRUCT) { static inline void generic_freestruct_tlsa(ARGS_FREESTRUCT) { - dns_rdata_tlsa_t *tlsa = source; + dns_rdata_tlsa_t *tlsa; + + REQUIRE(((dns_rdata_tlsa_t *)source) != NULL); - REQUIRE(tlsa != NULL); + tlsa = source; if (tlsa->mctx == NULL) return; @@ -257,10 +261,12 @@ fromstruct_tlsa(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_tlsa(ARGS_TOSTRUCT) { - dns_rdata_tlsa_t *tlsa = target; + dns_rdata_tlsa_t *tlsa; REQUIRE(rdata->type == dns_rdatatype_tlsa); - REQUIRE(tlsa != NULL); + REQUIRE(((dns_rdata_tlsa_t *)target) != NULL); + + tlsa = target; tlsa->common.rdclass = rdata->rdclass; tlsa->common.rdtype = rdata->type; @@ -271,10 +277,9 @@ tostruct_tlsa(ARGS_TOSTRUCT) { static inline void freestruct_tlsa(ARGS_FREESTRUCT) { - dns_rdata_tlsa_t *tlsa = source; - - REQUIRE(tlsa != NULL); - REQUIRE(tlsa->common.rdtype == dns_rdatatype_tlsa); + REQUIRE(((dns_rdata_tlsa_t *)source) != NULL); + REQUIRE(((dns_rdata_tlsa_t *)source)->common.rdtype == + dns_rdatatype_tlsa); generic_freestruct_tlsa(source); } diff --git a/lib/dns/rdata/generic/txt_16.c b/lib/dns/rdata/generic/txt_16.c index 21b0e4539ea..d63a852cc2e 100644 --- a/lib/dns/rdata/generic/txt_16.c +++ b/lib/dns/rdata/generic/txt_16.c @@ -134,14 +134,17 @@ compare_txt(ARGS_COMPARE) { static inline isc_result_t generic_fromstruct_txt(ARGS_FROMSTRUCT) { - dns_rdata_txt_t *txt = source; + dns_rdata_txt_t *txt; isc_region_t region; uint8_t length; - REQUIRE(txt != NULL); - REQUIRE(txt->common.rdtype == type); - REQUIRE(txt->common.rdclass == rdclass); - REQUIRE(txt->txt != NULL && txt->txt_len != 0); + REQUIRE(((dns_rdata_txt_t *)source) != NULL); + REQUIRE(((dns_rdata_txt_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_txt_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_txt_t *)source)->txt != NULL); + REQUIRE(((dns_rdata_txt_t *)source)->txt_len != 0); + + txt = source; UNUSED(type); UNUSED(rdclass); @@ -161,13 +164,15 @@ generic_fromstruct_txt(ARGS_FROMSTRUCT) { static inline isc_result_t generic_tostruct_txt(ARGS_TOSTRUCT) { - dns_rdata_txt_t *txt = target; + dns_rdata_txt_t *txt; isc_region_t r; - REQUIRE(txt != NULL); - REQUIRE(txt->common.rdclass == rdata->rdclass); - REQUIRE(txt->common.rdtype == rdata->type); - REQUIRE(!ISC_LINK_LINKED(&txt->common, link)); + REQUIRE(((dns_rdata_txt_t *)target) != NULL); + REQUIRE(((dns_rdata_txt_t *)target)->common.rdclass == rdata->rdclass); + REQUIRE(((dns_rdata_txt_t *)target)->common.rdtype == rdata->type); + REQUIRE(!ISC_LINK_LINKED(&((dns_rdata_txt_t *)target)->common, link)); + + txt = target; dns_rdata_toregion(rdata, &r); txt->txt_len = r.length; @@ -182,9 +187,11 @@ generic_tostruct_txt(ARGS_TOSTRUCT) { static inline void generic_freestruct_txt(ARGS_FREESTRUCT) { - dns_rdata_txt_t *txt = source; + dns_rdata_txt_t *txt; - REQUIRE(txt != NULL); + REQUIRE(((dns_rdata_txt_t *)source) != NULL); + + txt = source; if (txt->mctx == NULL) return; @@ -204,10 +211,12 @@ fromstruct_txt(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_txt(ARGS_TOSTRUCT) { - dns_rdata_txt_t *txt = target; + dns_rdata_txt_t *txt; REQUIRE(rdata->type == dns_rdatatype_txt); - REQUIRE(txt != NULL); + REQUIRE(((dns_rdata_txt_t *)target) != NULL); + + txt = target; txt->common.rdclass = rdata->rdclass; txt->common.rdtype = rdata->type; @@ -218,10 +227,9 @@ tostruct_txt(ARGS_TOSTRUCT) { static inline void freestruct_txt(ARGS_FREESTRUCT) { - dns_rdata_txt_t *txt = source; - - REQUIRE(txt != NULL); - REQUIRE(txt->common.rdtype == dns_rdatatype_txt); + REQUIRE(((dns_rdata_txt_t *)source) != NULL); + REQUIRE(((dns_rdata_txt_t *)source)->common.rdtype == + dns_rdatatype_txt); generic_freestruct_txt(source); } diff --git a/lib/dns/rdata/generic/uri_256.c b/lib/dns/rdata/generic/uri_256.c index 0a8801a81ec..0266c97deb4 100644 --- a/lib/dns/rdata/generic/uri_256.c +++ b/lib/dns/rdata/generic/uri_256.c @@ -168,13 +168,16 @@ compare_uri(ARGS_COMPARE) { static inline isc_result_t fromstruct_uri(ARGS_FROMSTRUCT) { - dns_rdata_uri_t *uri = source; + dns_rdata_uri_t *uri; REQUIRE(type == dns_rdatatype_uri); - REQUIRE(uri != NULL); - REQUIRE(uri->common.rdtype == type); - REQUIRE(uri->common.rdclass == rdclass); - REQUIRE(uri->target != NULL && uri->tgt_len != 0); + REQUIRE(((dns_rdata_uri_t *)source) != NULL); + REQUIRE(((dns_rdata_uri_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_uri_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_uri_t *)source)->target != NULL); + REQUIRE(((dns_rdata_uri_t *)source)->tgt_len != 0); + + uri = source; UNUSED(type); UNUSED(rdclass); @@ -197,13 +200,15 @@ fromstruct_uri(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_uri(ARGS_TOSTRUCT) { - dns_rdata_uri_t *uri = target; + dns_rdata_uri_t *uri; isc_region_t sr; + REQUIRE(((dns_rdata_uri_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_uri); - REQUIRE(uri != NULL); REQUIRE(rdata->length != 0); + uri = target; + uri->common.rdclass = rdata->rdclass; uri->common.rdtype = rdata->type; ISC_LINK_INIT(&uri->common, link); @@ -240,10 +245,13 @@ tostruct_uri(ARGS_TOSTRUCT) { static inline void freestruct_uri(ARGS_FREESTRUCT) { - dns_rdata_uri_t *uri = (dns_rdata_uri_t *) source; + dns_rdata_uri_t *uri; + + REQUIRE(((dns_rdata_uri_t *)source) != NULL); + REQUIRE(((dns_rdata_uri_t *)source)->common.rdtype == + dns_rdatatype_uri); - REQUIRE(uri != NULL); - REQUIRE(uri->common.rdtype == dns_rdatatype_uri); + uri = (dns_rdata_uri_t *) source; if (uri->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/x25_19.c b/lib/dns/rdata/generic/x25_19.c index 5dc9e2e36e1..c1bc19b972c 100644 --- a/lib/dns/rdata/generic/x25_19.c +++ b/lib/dns/rdata/generic/x25_19.c @@ -98,14 +98,17 @@ compare_x25(ARGS_COMPARE) { static inline isc_result_t fromstruct_x25(ARGS_FROMSTRUCT) { - dns_rdata_x25_t *x25 = source; + dns_rdata_x25_t *x25; uint8_t i; REQUIRE(type == dns_rdatatype_x25); - REQUIRE(x25 != NULL); - REQUIRE(x25->common.rdtype == type); - REQUIRE(x25->common.rdclass == rdclass); - REQUIRE(x25->x25 != NULL && x25->x25_len != 0); + REQUIRE(((dns_rdata_x25_t *)source) != NULL); + REQUIRE(((dns_rdata_x25_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_x25_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_x25_t *)source)->x25 != NULL); + REQUIRE(((dns_rdata_x25_t *)source)->x25_len != 0); + + x25 = source; UNUSED(type); UNUSED(rdclass); @@ -123,13 +126,15 @@ fromstruct_x25(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_x25(ARGS_TOSTRUCT) { - dns_rdata_x25_t *x25 = target; + dns_rdata_x25_t *x25; isc_region_t r; + REQUIRE(((dns_rdata_x25_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_x25); - REQUIRE(x25 != NULL); REQUIRE(rdata->length != 0); + x25 = target; + x25->common.rdclass = rdata->rdclass; x25->common.rdtype = rdata->type; ISC_LINK_INIT(&x25->common, link); @@ -147,10 +152,13 @@ tostruct_x25(ARGS_TOSTRUCT) { static inline void freestruct_x25(ARGS_FREESTRUCT) { - dns_rdata_x25_t *x25 = source; + dns_rdata_x25_t *x25; + + REQUIRE(((dns_rdata_x25_t *)source) != NULL); + REQUIRE(((dns_rdata_x25_t *)source)->common.rdtype == + dns_rdatatype_x25); - REQUIRE(x25 != NULL); - REQUIRE(x25->common.rdtype == dns_rdatatype_x25); + x25 = source; if (x25->mctx == NULL) return; diff --git a/lib/dns/rdata/generic/zonemd_63.c b/lib/dns/rdata/generic/zonemd_63.c index 0c918063549..f9f2476d3da 100644 --- a/lib/dns/rdata/generic/zonemd_63.c +++ b/lib/dns/rdata/generic/zonemd_63.c @@ -194,11 +194,13 @@ compare_zonemd(ARGS_COMPARE) { static inline isc_result_t fromstruct_zonemd(ARGS_FROMSTRUCT) { - dns_rdata_zonemd_t *zonemd = source; + dns_rdata_zonemd_t *zonemd; - REQUIRE(zonemd != NULL); - REQUIRE(zonemd->common.rdtype == type); - REQUIRE(zonemd->common.rdclass == rdclass); + REQUIRE(((dns_rdata_zonemd_t *)source) != NULL); + REQUIRE(((dns_rdata_zonemd_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_zonemd_t *)source)->common.rdclass == rdclass); + + zonemd = source; UNUSED(type); UNUSED(rdclass); @@ -218,13 +220,15 @@ fromstruct_zonemd(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_zonemd(ARGS_TOSTRUCT) { - dns_rdata_zonemd_t *zonemd = target; + dns_rdata_zonemd_t *zonemd; isc_region_t region; + REQUIRE(((dns_rdata_zonemd_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_zonemd); - REQUIRE(zonemd != NULL); REQUIRE(rdata->length != 0); + zonemd = target; + zonemd->common.rdclass = rdata->rdclass; zonemd->common.rdtype = rdata->type; ISC_LINK_INIT(&zonemd->common, link); @@ -250,10 +254,13 @@ tostruct_zonemd(ARGS_TOSTRUCT) { static inline void freestruct_zonemd(ARGS_FREESTRUCT) { - dns_rdata_zonemd_t *zonemd = source; + dns_rdata_zonemd_t *zonemd; + + REQUIRE(((dns_rdata_zonemd_t *)source) != NULL); + REQUIRE(((dns_rdata_zonemd_t *)source)->common.rdtype == + dns_rdatatype_zonemd); - REQUIRE(zonemd != NULL); - REQUIRE(zonemd->common.rdtype == dns_rdatatype_zonemd); + zonemd = source; if (zonemd->mctx == NULL) { return; diff --git a/lib/dns/rdata/hs_4/a_1.c b/lib/dns/rdata/hs_4/a_1.c index b328e898e66..69a0f0bc9e8 100644 --- a/lib/dns/rdata/hs_4/a_1.c +++ b/lib/dns/rdata/hs_4/a_1.c @@ -121,14 +121,16 @@ compare_hs_a(ARGS_COMPARE) { static inline isc_result_t fromstruct_hs_a(ARGS_FROMSTRUCT) { - dns_rdata_hs_a_t *a = source; + dns_rdata_hs_a_t *a; uint32_t n; REQUIRE(type == dns_rdatatype_a); REQUIRE(rdclass == dns_rdataclass_hs); - REQUIRE(a != NULL); - REQUIRE(a->common.rdtype == type); - REQUIRE(a->common.rdclass == rdclass); + REQUIRE(((dns_rdata_hs_a_t *)source) != NULL); + REQUIRE(((dns_rdata_hs_a_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_hs_a_t *)source)->common.rdclass == rdclass); + + a = source; UNUSED(type); UNUSED(rdclass); @@ -140,14 +142,16 @@ fromstruct_hs_a(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_hs_a(ARGS_TOSTRUCT) { - dns_rdata_hs_a_t *a = target; + dns_rdata_hs_a_t *a; uint32_t n; isc_region_t region; REQUIRE(rdata->type == dns_rdatatype_a); REQUIRE(rdata->rdclass == dns_rdataclass_hs); REQUIRE(rdata->length == 4); - REQUIRE(a != NULL); + REQUIRE(((dns_rdata_hs_a_t *)target) != NULL); + + a = target; UNUSED(mctx); diff --git a/lib/dns/rdata/in_1/a6_38.c b/lib/dns/rdata/in_1/a6_38.c index 20213f555f3..059e795bf59 100644 --- a/lib/dns/rdata/in_1/a6_38.c +++ b/lib/dns/rdata/in_1/a6_38.c @@ -270,7 +270,7 @@ compare_in_a6(ARGS_COMPARE) { static inline isc_result_t fromstruct_in_a6(ARGS_FROMSTRUCT) { - dns_rdata_in_a6_t *a6 = source; + dns_rdata_in_a6_t *a6; isc_region_t region; int octets; uint8_t bits; @@ -279,9 +279,11 @@ fromstruct_in_a6(ARGS_FROMSTRUCT) { REQUIRE(type == dns_rdatatype_a6); REQUIRE(rdclass == dns_rdataclass_in); - REQUIRE(a6 != NULL); - REQUIRE(a6->common.rdtype == type); - REQUIRE(a6->common.rdclass == rdclass); + REQUIRE(((dns_rdata_in_a6_t *)source) != NULL); + REQUIRE(((dns_rdata_in_a6_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_in_a6_t *)source)->common.rdclass == rdclass); + + a6 = source; UNUSED(type); UNUSED(rdclass); @@ -315,16 +317,18 @@ fromstruct_in_a6(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_in_a6(ARGS_TOSTRUCT) { - dns_rdata_in_a6_t *a6 = target; + dns_rdata_in_a6_t *a6; unsigned char octets; dns_name_t name; isc_region_t r; + REQUIRE(((dns_rdata_in_a6_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_a6); REQUIRE(rdata->rdclass == dns_rdataclass_in); - REQUIRE(a6 != NULL); REQUIRE(rdata->length != 0); + a6 = target; + a6->common.rdclass = rdata->rdclass; a6->common.rdtype = rdata->type; ISC_LINK_INIT(&a6->common, link); @@ -360,11 +364,15 @@ tostruct_in_a6(ARGS_TOSTRUCT) { static inline void freestruct_in_a6(ARGS_FREESTRUCT) { - dns_rdata_in_a6_t *a6 = source; + dns_rdata_in_a6_t *a6; + + REQUIRE(((dns_rdata_in_a6_t *)source) != NULL); + REQUIRE(((dns_rdata_in_a6_t *)source)->common.rdtype == + dns_rdatatype_a6); + REQUIRE(((dns_rdata_in_a6_t *)source)->common.rdclass == + dns_rdataclass_in); - REQUIRE(a6 != NULL); - REQUIRE(a6->common.rdclass == dns_rdataclass_in); - REQUIRE(a6->common.rdtype == dns_rdatatype_a6); + a6 = source; if (a6->mctx == NULL) return; diff --git a/lib/dns/rdata/in_1/a_1.c b/lib/dns/rdata/in_1/a_1.c index 04b6e9d787e..9c8a0cd5e9c 100644 --- a/lib/dns/rdata/in_1/a_1.c +++ b/lib/dns/rdata/in_1/a_1.c @@ -122,14 +122,16 @@ compare_in_a(ARGS_COMPARE) { static inline isc_result_t fromstruct_in_a(ARGS_FROMSTRUCT) { - dns_rdata_in_a_t *a = source; + dns_rdata_in_a_t *a; uint32_t n; REQUIRE(type == dns_rdatatype_a); REQUIRE(rdclass == dns_rdataclass_in); - REQUIRE(a != NULL); - REQUIRE(a->common.rdtype == type); - REQUIRE(a->common.rdclass == rdclass); + REQUIRE(((dns_rdata_in_a_t *)source) != NULL); + REQUIRE(((dns_rdata_in_a_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_in_a_t *)source)->common.rdclass == rdclass); + + a = source; UNUSED(type); UNUSED(rdclass); @@ -142,15 +144,17 @@ fromstruct_in_a(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_in_a(ARGS_TOSTRUCT) { - dns_rdata_in_a_t *a = target; + dns_rdata_in_a_t *a; uint32_t n; isc_region_t region; - REQUIRE(a != NULL); + REQUIRE(((dns_rdata_in_a_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_a); REQUIRE(rdata->rdclass == dns_rdataclass_in); REQUIRE(rdata->length == 4); + a = target; + UNUSED(mctx); a->common.rdclass = rdata->rdclass; @@ -166,11 +170,14 @@ tostruct_in_a(ARGS_TOSTRUCT) { static inline void freestruct_in_a(ARGS_FREESTRUCT) { - dns_rdata_in_a_t *a = source; + dns_rdata_in_a_t *a; + + REQUIRE(((dns_rdata_in_a_t *)source) != NULL); + REQUIRE(((dns_rdata_in_a_t *)source)->common.rdtype == dns_rdatatype_a); + REQUIRE(((dns_rdata_in_a_t *)source)->common.rdclass == + dns_rdataclass_in); - REQUIRE(a != NULL); - REQUIRE(a->common.rdtype == dns_rdatatype_a); - REQUIRE(a->common.rdclass == dns_rdataclass_in); + a = source; UNUSED(a); } diff --git a/lib/dns/rdata/in_1/aaaa_28.c b/lib/dns/rdata/in_1/aaaa_28.c index b82151ed2e6..09794510890 100644 --- a/lib/dns/rdata/in_1/aaaa_28.c +++ b/lib/dns/rdata/in_1/aaaa_28.c @@ -123,13 +123,15 @@ compare_in_aaaa(ARGS_COMPARE) { static inline isc_result_t fromstruct_in_aaaa(ARGS_FROMSTRUCT) { - dns_rdata_in_aaaa_t *aaaa = source; + dns_rdata_in_aaaa_t *aaaa; REQUIRE(type == dns_rdatatype_aaaa); REQUIRE(rdclass == dns_rdataclass_in); - REQUIRE(aaaa != NULL); - REQUIRE(aaaa->common.rdtype == type); - REQUIRE(aaaa->common.rdclass == rdclass); + REQUIRE(((dns_rdata_in_aaaa_t *)source) != NULL); + REQUIRE(((dns_rdata_in_aaaa_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_in_aaaa_t *)source)->common.rdclass == rdclass); + + aaaa = source; UNUSED(type); UNUSED(rdclass); @@ -139,14 +141,16 @@ fromstruct_in_aaaa(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_in_aaaa(ARGS_TOSTRUCT) { - dns_rdata_in_aaaa_t *aaaa = target; + dns_rdata_in_aaaa_t *aaaa; isc_region_t r; + REQUIRE(((dns_rdata_in_aaaa_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_aaaa); REQUIRE(rdata->rdclass == dns_rdataclass_in); - REQUIRE(aaaa != NULL); REQUIRE(rdata->length == 16); + aaaa = target; + UNUSED(mctx); aaaa->common.rdclass = rdata->rdclass; @@ -162,11 +166,15 @@ tostruct_in_aaaa(ARGS_TOSTRUCT) { static inline void freestruct_in_aaaa(ARGS_FREESTRUCT) { - dns_rdata_in_aaaa_t *aaaa = source; + dns_rdata_in_aaaa_t *aaaa; + + REQUIRE(((dns_rdata_in_aaaa_t *)source) != NULL); + REQUIRE(((dns_rdata_in_aaaa_t *)source)->common.rdtype == + dns_rdatatype_aaaa); + REQUIRE(((dns_rdata_in_aaaa_t *)source)->common.rdclass == + dns_rdataclass_in); - REQUIRE(aaaa != NULL); - REQUIRE(aaaa->common.rdclass == dns_rdataclass_in); - REQUIRE(aaaa->common.rdtype == dns_rdatatype_aaaa); + aaaa = source; UNUSED(aaaa); } diff --git a/lib/dns/rdata/in_1/apl_42.c b/lib/dns/rdata/in_1/apl_42.c index f376eba4c0e..7255b6ca7cf 100644 --- a/lib/dns/rdata/in_1/apl_42.c +++ b/lib/dns/rdata/in_1/apl_42.c @@ -243,15 +243,18 @@ compare_in_apl(ARGS_COMPARE) { static inline isc_result_t fromstruct_in_apl(ARGS_FROMSTRUCT) { - dns_rdata_in_apl_t *apl = source; + dns_rdata_in_apl_t *apl; isc_buffer_t b; REQUIRE(type == dns_rdatatype_apl); REQUIRE(rdclass == dns_rdataclass_in); - REQUIRE(apl != NULL); - REQUIRE(apl->common.rdtype == type); - REQUIRE(apl->common.rdclass == rdclass); - REQUIRE(apl->apl != NULL || apl->apl_len == 0); + REQUIRE(((dns_rdata_in_apl_t *)source) != NULL); + REQUIRE(((dns_rdata_in_apl_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_in_apl_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_in_apl_t *)source)->apl != NULL || + ((dns_rdata_in_apl_t *)source)->apl_len == 0); + + apl = source; isc_buffer_init(&b, apl->apl, apl->apl_len); isc_buffer_add(&b, apl->apl_len); @@ -261,13 +264,15 @@ fromstruct_in_apl(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_in_apl(ARGS_TOSTRUCT) { - dns_rdata_in_apl_t *apl = target; + dns_rdata_in_apl_t *apl; isc_region_t r; - REQUIRE(apl != NULL); + REQUIRE(((dns_rdata_in_apl_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_apl); REQUIRE(rdata->rdclass == dns_rdataclass_in); + apl = target; + apl->common.rdclass = rdata->rdclass; apl->common.rdtype = rdata->type; ISC_LINK_INIT(&apl->common, link); @@ -285,11 +290,15 @@ tostruct_in_apl(ARGS_TOSTRUCT) { static inline void freestruct_in_apl(ARGS_FREESTRUCT) { - dns_rdata_in_apl_t *apl = source; + dns_rdata_in_apl_t *apl; - REQUIRE(apl != NULL); - REQUIRE(apl->common.rdtype == dns_rdatatype_apl); - REQUIRE(apl->common.rdclass == dns_rdataclass_in); + REQUIRE(((dns_rdata_in_apl_t *)source) != NULL); + REQUIRE(((dns_rdata_in_apl_t *)source)->common.rdtype == + dns_rdatatype_apl); + REQUIRE(((dns_rdata_in_apl_t *)source)->common.rdclass == + dns_rdataclass_in); + + apl = source; if (apl->mctx == NULL) return; diff --git a/lib/dns/rdata/in_1/atma_34.c b/lib/dns/rdata/in_1/atma_34.c index c232b3feacb..9817ec536d8 100644 --- a/lib/dns/rdata/in_1/atma_34.c +++ b/lib/dns/rdata/in_1/atma_34.c @@ -197,14 +197,17 @@ compare_in_atma(ARGS_COMPARE) { static inline isc_result_t fromstruct_in_atma(ARGS_FROMSTRUCT) { - dns_rdata_in_atma_t *atma = source; + dns_rdata_in_atma_t *atma; REQUIRE(type == dns_rdatatype_atma); REQUIRE(rdclass == dns_rdataclass_in); - REQUIRE(atma != NULL); - REQUIRE(atma->common.rdtype == type); - REQUIRE(atma->common.rdclass == rdclass); - REQUIRE(atma->atma != NULL || atma->atma_len == 0); + REQUIRE(((dns_rdata_in_atma_t *)source) != NULL); + REQUIRE(((dns_rdata_in_atma_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_in_atma_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_in_atma_t *)source)->atma != NULL || + ((dns_rdata_in_atma_t *)source)->atma_len == 0); + + atma = source; UNUSED(type); UNUSED(rdclass); @@ -215,14 +218,16 @@ fromstruct_in_atma(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_in_atma(ARGS_TOSTRUCT) { - dns_rdata_in_atma_t *atma = target; + dns_rdata_in_atma_t *atma; isc_region_t r; + REQUIRE(((dns_rdata_in_atma_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_atma); REQUIRE(rdata->rdclass == dns_rdataclass_in); - REQUIRE(atma != NULL); REQUIRE(rdata->length != 0); + atma = target; + atma->common.rdclass = rdata->rdclass; atma->common.rdtype = rdata->type; ISC_LINK_INIT(&atma->common, link); @@ -242,11 +247,15 @@ tostruct_in_atma(ARGS_TOSTRUCT) { static inline void freestruct_in_atma(ARGS_FREESTRUCT) { - dns_rdata_in_atma_t *atma = source; + dns_rdata_in_atma_t *atma; + + REQUIRE(((dns_rdata_in_atma_t *)source) != NULL); + REQUIRE(((dns_rdata_in_atma_t *)source)->common.rdtype == + dns_rdatatype_atma); + REQUIRE(((dns_rdata_in_atma_t *)source)->common.rdclass == + dns_rdataclass_in); - REQUIRE(atma != NULL); - REQUIRE(atma->common.rdclass == dns_rdataclass_in); - REQUIRE(atma->common.rdtype == dns_rdatatype_atma); + atma = source; if (atma->mctx == NULL) { return; diff --git a/lib/dns/rdata/in_1/dhcid_49.c b/lib/dns/rdata/in_1/dhcid_49.c index 7722e466d0c..17c45597c5e 100644 --- a/lib/dns/rdata/in_1/dhcid_49.c +++ b/lib/dns/rdata/in_1/dhcid_49.c @@ -117,14 +117,16 @@ compare_in_dhcid(ARGS_COMPARE) { static inline isc_result_t fromstruct_in_dhcid(ARGS_FROMSTRUCT) { - dns_rdata_in_dhcid_t *dhcid = source; + dns_rdata_in_dhcid_t *dhcid; REQUIRE(type == dns_rdatatype_dhcid); REQUIRE(rdclass == dns_rdataclass_in); - REQUIRE(dhcid != NULL); - REQUIRE(dhcid->common.rdtype == type); - REQUIRE(dhcid->common.rdclass == rdclass); - REQUIRE(dhcid->length != 0); + REQUIRE(((dns_rdata_in_dhcid_t *)source) != NULL); + REQUIRE(((dns_rdata_in_dhcid_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_in_dhcid_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_in_dhcid_t *)source)->length != 0); + + dhcid = source; UNUSED(type); UNUSED(rdclass); @@ -134,14 +136,16 @@ fromstruct_in_dhcid(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_in_dhcid(ARGS_TOSTRUCT) { - dns_rdata_in_dhcid_t *dhcid = target; + dns_rdata_in_dhcid_t *dhcid; isc_region_t region; + REQUIRE(((dns_rdata_in_dhcid_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_dhcid); REQUIRE(rdata->rdclass == dns_rdataclass_in); - REQUIRE(dhcid != NULL); REQUIRE(rdata->length != 0); + dhcid = target; + dhcid->common.rdclass = rdata->rdclass; dhcid->common.rdtype = rdata->type; ISC_LINK_INIT(&dhcid->common, link); @@ -158,11 +162,15 @@ tostruct_in_dhcid(ARGS_TOSTRUCT) { static inline void freestruct_in_dhcid(ARGS_FREESTRUCT) { - dns_rdata_in_dhcid_t *dhcid = source; + dns_rdata_in_dhcid_t *dhcid; + + REQUIRE(((dns_rdata_in_dhcid_t *)source) != NULL); + REQUIRE(((dns_rdata_in_dhcid_t *)source)->common.rdtype == + dns_rdatatype_dhcid); + REQUIRE(((dns_rdata_in_dhcid_t *)source)->common.rdclass == + dns_rdataclass_in); - REQUIRE(dhcid != NULL); - REQUIRE(dhcid->common.rdtype == dns_rdatatype_dhcid); - REQUIRE(dhcid->common.rdclass == dns_rdataclass_in); + dhcid = source; if (dhcid->mctx == NULL) return; diff --git a/lib/dns/rdata/in_1/eid_31.c b/lib/dns/rdata/in_1/eid_31.c index 627d2f1e1a0..78e9aae2b7b 100644 --- a/lib/dns/rdata/in_1/eid_31.c +++ b/lib/dns/rdata/in_1/eid_31.c @@ -108,14 +108,17 @@ compare_in_eid(ARGS_COMPARE) { static inline isc_result_t fromstruct_in_eid(ARGS_FROMSTRUCT) { - dns_rdata_in_eid_t *eid = source; + dns_rdata_in_eid_t *eid; REQUIRE(type == dns_rdatatype_eid); REQUIRE(rdclass == dns_rdataclass_in); - REQUIRE(eid != NULL); - REQUIRE(eid->common.rdtype == type); - REQUIRE(eid->common.rdclass == rdclass); - REQUIRE(eid->eid != NULL || eid->eid_len == 0); + REQUIRE(((dns_rdata_in_eid_t *)source) != NULL); + REQUIRE(((dns_rdata_in_eid_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_in_eid_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_in_eid_t *)source)->eid != NULL || + ((dns_rdata_in_eid_t *)source)->eid_len == 0); + + eid = source; UNUSED(type); UNUSED(rdclass); @@ -125,14 +128,16 @@ fromstruct_in_eid(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_in_eid(ARGS_TOSTRUCT) { - dns_rdata_in_eid_t *eid = target; + dns_rdata_in_eid_t *eid; isc_region_t r; + REQUIRE(((dns_rdata_in_eid_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_eid); REQUIRE(rdata->rdclass == dns_rdataclass_in); - REQUIRE(eid != NULL); REQUIRE(rdata->length != 0); + eid = target; + eid->common.rdclass = rdata->rdclass; eid->common.rdtype = rdata->type; ISC_LINK_INIT(&eid->common, link); @@ -150,11 +155,15 @@ tostruct_in_eid(ARGS_TOSTRUCT) { static inline void freestruct_in_eid(ARGS_FREESTRUCT) { - dns_rdata_in_eid_t *eid = source; + dns_rdata_in_eid_t *eid; + + REQUIRE(((dns_rdata_in_eid_t *)source) != NULL); + REQUIRE(((dns_rdata_in_eid_t *)source)->common.rdtype == + dns_rdatatype_eid); + REQUIRE(((dns_rdata_in_eid_t *)source)->common.rdclass == + dns_rdataclass_in); - REQUIRE(eid != NULL); - REQUIRE(eid->common.rdclass == dns_rdataclass_in); - REQUIRE(eid->common.rdtype == dns_rdatatype_eid); + eid = source; if (eid->mctx == NULL) { return; diff --git a/lib/dns/rdata/in_1/kx_36.c b/lib/dns/rdata/in_1/kx_36.c index 7431b919972..65ff851e848 100644 --- a/lib/dns/rdata/in_1/kx_36.c +++ b/lib/dns/rdata/in_1/kx_36.c @@ -154,14 +154,16 @@ compare_in_kx(ARGS_COMPARE) { static inline isc_result_t fromstruct_in_kx(ARGS_FROMSTRUCT) { - dns_rdata_in_kx_t *kx = source; + dns_rdata_in_kx_t *kx; isc_region_t region; REQUIRE(type == dns_rdatatype_kx); REQUIRE(rdclass == dns_rdataclass_in); - REQUIRE(kx != NULL); - REQUIRE(kx->common.rdtype == type); - REQUIRE(kx->common.rdclass == rdclass); + REQUIRE(((dns_rdata_in_kx_t *)source) != NULL); + REQUIRE(((dns_rdata_in_kx_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_in_kx_t *)source)->common.rdclass == rdclass); + + kx = source; UNUSED(type); UNUSED(rdclass); @@ -174,14 +176,16 @@ fromstruct_in_kx(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_in_kx(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_in_kx_t *kx = target; + dns_rdata_in_kx_t *kx; dns_name_t name; + REQUIRE(((dns_rdata_in_kx_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_kx); REQUIRE(rdata->rdclass == dns_rdataclass_in); - REQUIRE(kx != NULL); REQUIRE(rdata->length != 0); + kx = target; + kx->common.rdclass = rdata->rdclass; kx->common.rdtype = rdata->type; ISC_LINK_INIT(&kx->common, link); @@ -201,11 +205,15 @@ tostruct_in_kx(ARGS_TOSTRUCT) { static inline void freestruct_in_kx(ARGS_FREESTRUCT) { - dns_rdata_in_kx_t *kx = source; + dns_rdata_in_kx_t *kx; + + REQUIRE(((dns_rdata_in_kx_t *)source) != NULL); + REQUIRE(((dns_rdata_in_kx_t *)source)->common.rdtype == + dns_rdatatype_kx); + REQUIRE(((dns_rdata_in_kx_t *)source)->common.rdclass == + dns_rdataclass_in); - REQUIRE(kx != NULL); - REQUIRE(kx->common.rdclass == dns_rdataclass_in); - REQUIRE(kx->common.rdtype == dns_rdatatype_kx); + kx = source; if (kx->mctx == NULL) return; diff --git a/lib/dns/rdata/in_1/nimloc_32.c b/lib/dns/rdata/in_1/nimloc_32.c index aba3481c57a..7780f062069 100644 --- a/lib/dns/rdata/in_1/nimloc_32.c +++ b/lib/dns/rdata/in_1/nimloc_32.c @@ -108,14 +108,17 @@ compare_in_nimloc(ARGS_COMPARE) { static inline isc_result_t fromstruct_in_nimloc(ARGS_FROMSTRUCT) { - dns_rdata_in_nimloc_t *nimloc = source; + dns_rdata_in_nimloc_t *nimloc; REQUIRE(type == dns_rdatatype_nimloc); REQUIRE(rdclass == dns_rdataclass_in); - REQUIRE(nimloc != NULL); - REQUIRE(nimloc->common.rdtype == type); - REQUIRE(nimloc->common.rdclass == rdclass); - REQUIRE(nimloc->nimloc != NULL || nimloc->nimloc_len == 0); + REQUIRE(((dns_rdata_in_nimloc_t *)source) != NULL); + REQUIRE(((dns_rdata_in_nimloc_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_in_nimloc_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_in_nimloc_t *)source)->nimloc != NULL || + ((dns_rdata_in_nimloc_t *)source)->nimloc_len == 0); + + nimloc = source; UNUSED(type); UNUSED(rdclass); @@ -125,14 +128,16 @@ fromstruct_in_nimloc(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_in_nimloc(ARGS_TOSTRUCT) { - dns_rdata_in_nimloc_t *nimloc = target; + dns_rdata_in_nimloc_t *nimloc; isc_region_t r; + REQUIRE(((dns_rdata_in_nimloc_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_nimloc); REQUIRE(rdata->rdclass == dns_rdataclass_in); - REQUIRE(nimloc != NULL); REQUIRE(rdata->length != 0); + nimloc = target; + nimloc->common.rdclass = rdata->rdclass; nimloc->common.rdtype = rdata->type; ISC_LINK_INIT(&nimloc->common, link); @@ -150,11 +155,15 @@ tostruct_in_nimloc(ARGS_TOSTRUCT) { static inline void freestruct_in_nimloc(ARGS_FREESTRUCT) { - dns_rdata_in_nimloc_t *nimloc = source; + dns_rdata_in_nimloc_t *nimloc; + + REQUIRE(((dns_rdata_in_nimloc_t *)source) != NULL); + REQUIRE(((dns_rdata_in_nimloc_t *)source)->common.rdtype == + dns_rdatatype_nimloc); + REQUIRE(((dns_rdata_in_nimloc_t *)source)->common.rdclass == + dns_rdataclass_in); - REQUIRE(nimloc != NULL); - REQUIRE(nimloc->common.rdclass == dns_rdataclass_in); - REQUIRE(nimloc->common.rdtype == dns_rdatatype_nimloc); + nimloc = source; if (nimloc->mctx == NULL) { return; diff --git a/lib/dns/rdata/in_1/nsap-ptr_23.c b/lib/dns/rdata/in_1/nsap-ptr_23.c index 98953e4b376..a4ec606c6f8 100644 --- a/lib/dns/rdata/in_1/nsap-ptr_23.c +++ b/lib/dns/rdata/in_1/nsap-ptr_23.c @@ -124,14 +124,16 @@ compare_in_nsap_ptr(ARGS_COMPARE) { static inline isc_result_t fromstruct_in_nsap_ptr(ARGS_FROMSTRUCT) { - dns_rdata_in_nsap_ptr_t *nsap_ptr = source; + dns_rdata_in_nsap_ptr_t *nsap_ptr; isc_region_t region; REQUIRE(type == dns_rdatatype_nsap_ptr); REQUIRE(rdclass == dns_rdataclass_in); - REQUIRE(nsap_ptr != NULL); - REQUIRE(nsap_ptr->common.rdtype == type); - REQUIRE(nsap_ptr->common.rdclass == rdclass); + REQUIRE(((dns_rdata_in_nsap_ptr_t *)source) != NULL); + REQUIRE(((dns_rdata_in_nsap_ptr_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_in_nsap_ptr_t *)source)->common.rdclass == rdclass); + + nsap_ptr = source; UNUSED(type); UNUSED(rdclass); @@ -143,14 +145,16 @@ fromstruct_in_nsap_ptr(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_in_nsap_ptr(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_in_nsap_ptr_t *nsap_ptr = target; + dns_rdata_in_nsap_ptr_t *nsap_ptr; dns_name_t name; + REQUIRE(((dns_rdata_in_nsap_ptr_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_nsap_ptr); REQUIRE(rdata->rdclass == dns_rdataclass_in); - REQUIRE(nsap_ptr != NULL); REQUIRE(rdata->length != 0); + nsap_ptr = target; + nsap_ptr->common.rdclass = rdata->rdclass; nsap_ptr->common.rdtype = rdata->type; ISC_LINK_INIT(&nsap_ptr->common, link); @@ -166,11 +170,15 @@ tostruct_in_nsap_ptr(ARGS_TOSTRUCT) { static inline void freestruct_in_nsap_ptr(ARGS_FREESTRUCT) { - dns_rdata_in_nsap_ptr_t *nsap_ptr = source; + dns_rdata_in_nsap_ptr_t *nsap_ptr; + + REQUIRE(((dns_rdata_in_nsap_ptr_t *)source) != NULL); + REQUIRE(((dns_rdata_in_nsap_ptr_t *)source)->common.rdtype == + dns_rdatatype_nsap_ptr); + REQUIRE(((dns_rdata_in_nsap_ptr_t *)source)->common.rdclass == + dns_rdataclass_in); - REQUIRE(nsap_ptr != NULL); - REQUIRE(nsap_ptr->common.rdclass == dns_rdataclass_in); - REQUIRE(nsap_ptr->common.rdtype == dns_rdatatype_nsap_ptr); + nsap_ptr = source; if (nsap_ptr->mctx == NULL) return; diff --git a/lib/dns/rdata/in_1/nsap_22.c b/lib/dns/rdata/in_1/nsap_22.c index c08473e17ac..027db47af15 100644 --- a/lib/dns/rdata/in_1/nsap_22.c +++ b/lib/dns/rdata/in_1/nsap_22.c @@ -137,14 +137,17 @@ compare_in_nsap(ARGS_COMPARE) { static inline isc_result_t fromstruct_in_nsap(ARGS_FROMSTRUCT) { - dns_rdata_in_nsap_t *nsap = source; + dns_rdata_in_nsap_t *nsap; REQUIRE(type == dns_rdatatype_nsap); REQUIRE(rdclass == dns_rdataclass_in); - REQUIRE(nsap != NULL); - REQUIRE(nsap->common.rdtype == type); - REQUIRE(nsap->common.rdclass == rdclass); - REQUIRE(nsap->nsap != NULL || nsap->nsap_len == 0); + REQUIRE(((dns_rdata_in_nsap_t *)source) != NULL); + REQUIRE(((dns_rdata_in_nsap_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_in_nsap_t *)source)->common.rdclass == rdclass); + REQUIRE(((dns_rdata_in_nsap_t *)source)->nsap != NULL || + ((dns_rdata_in_nsap_t *)source)->nsap_len == 0); + + nsap = source; UNUSED(type); UNUSED(rdclass); @@ -154,14 +157,16 @@ fromstruct_in_nsap(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_in_nsap(ARGS_TOSTRUCT) { - dns_rdata_in_nsap_t *nsap = target; + dns_rdata_in_nsap_t *nsap; isc_region_t r; + REQUIRE(((dns_rdata_in_nsap_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_nsap); REQUIRE(rdata->rdclass == dns_rdataclass_in); - REQUIRE(nsap != NULL); REQUIRE(rdata->length != 0); + nsap = target; + nsap->common.rdclass = rdata->rdclass; nsap->common.rdtype = rdata->type; ISC_LINK_INIT(&nsap->common, link); @@ -178,11 +183,15 @@ tostruct_in_nsap(ARGS_TOSTRUCT) { static inline void freestruct_in_nsap(ARGS_FREESTRUCT) { - dns_rdata_in_nsap_t *nsap = source; + dns_rdata_in_nsap_t *nsap; + + REQUIRE(((dns_rdata_in_nsap_t *)source) != NULL); + REQUIRE(((dns_rdata_in_nsap_t *)source)->common.rdclass == + dns_rdataclass_in); + REQUIRE(((dns_rdata_in_nsap_t *)source)->common.rdtype == + dns_rdatatype_nsap); - REQUIRE(nsap != NULL); - REQUIRE(nsap->common.rdclass == dns_rdataclass_in); - REQUIRE(nsap->common.rdtype == dns_rdatatype_nsap); + nsap = source; if (nsap->mctx == NULL) return; diff --git a/lib/dns/rdata/in_1/px_26.c b/lib/dns/rdata/in_1/px_26.c index bb69223f864..6eb9825417f 100644 --- a/lib/dns/rdata/in_1/px_26.c +++ b/lib/dns/rdata/in_1/px_26.c @@ -219,14 +219,16 @@ compare_in_px(ARGS_COMPARE) { static inline isc_result_t fromstruct_in_px(ARGS_FROMSTRUCT) { - dns_rdata_in_px_t *px = source; + dns_rdata_in_px_t *px; isc_region_t region; REQUIRE(type == dns_rdatatype_px); REQUIRE(rdclass == dns_rdataclass_in); - REQUIRE(px != NULL); - REQUIRE(px->common.rdtype == type); - REQUIRE(px->common.rdclass == rdclass); + REQUIRE(((dns_rdata_in_px_t *)source) != NULL); + REQUIRE(((dns_rdata_in_px_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_in_px_t *)source)->common.rdclass == rdclass); + + px = source; UNUSED(type); UNUSED(rdclass); @@ -240,16 +242,18 @@ fromstruct_in_px(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_in_px(ARGS_TOSTRUCT) { - dns_rdata_in_px_t *px = target; + dns_rdata_in_px_t *px; dns_name_t name; isc_region_t region; isc_result_t result; + REQUIRE(((dns_rdata_in_px_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_px); REQUIRE(rdata->rdclass == dns_rdataclass_in); - REQUIRE(px != NULL); REQUIRE(rdata->length != 0); + px = target; + px->common.rdclass = rdata->rdclass; px->common.rdtype = rdata->type; ISC_LINK_INIT(&px->common, link); @@ -281,11 +285,15 @@ tostruct_in_px(ARGS_TOSTRUCT) { static inline void freestruct_in_px(ARGS_FREESTRUCT) { - dns_rdata_in_px_t *px = source; + dns_rdata_in_px_t *px; + + REQUIRE(((dns_rdata_in_px_t *)source) != NULL); + REQUIRE(((dns_rdata_in_px_t *)source)->common.rdtype == + dns_rdatatype_px); + REQUIRE(((dns_rdata_in_px_t *)source)->common.rdclass == + dns_rdataclass_in); - REQUIRE(px != NULL); - REQUIRE(px->common.rdclass == dns_rdataclass_in); - REQUIRE(px->common.rdtype == dns_rdatatype_px); + px = source; if (px->mctx == NULL) return; diff --git a/lib/dns/rdata/in_1/srv_33.c b/lib/dns/rdata/in_1/srv_33.c index 385bdaa0492..e706ae0a66b 100644 --- a/lib/dns/rdata/in_1/srv_33.c +++ b/lib/dns/rdata/in_1/srv_33.c @@ -226,14 +226,16 @@ compare_in_srv(ARGS_COMPARE) { static inline isc_result_t fromstruct_in_srv(ARGS_FROMSTRUCT) { - dns_rdata_in_srv_t *srv = source; + dns_rdata_in_srv_t *srv; isc_region_t region; REQUIRE(type == dns_rdatatype_srv); REQUIRE(rdclass == dns_rdataclass_in); - REQUIRE(srv != NULL); - REQUIRE(srv->common.rdtype == type); - REQUIRE(srv->common.rdclass == rdclass); + REQUIRE(((dns_rdata_in_srv_t *)source) != NULL); + REQUIRE(((dns_rdata_in_srv_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_in_srv_t *)source)->common.rdclass == rdclass); + + srv = source; UNUSED(type); UNUSED(rdclass); @@ -248,14 +250,16 @@ fromstruct_in_srv(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_in_srv(ARGS_TOSTRUCT) { isc_region_t region; - dns_rdata_in_srv_t *srv = target; + dns_rdata_in_srv_t *srv; dns_name_t name; + REQUIRE(((dns_rdata_in_srv_t *)target) != NULL); REQUIRE(rdata->rdclass == dns_rdataclass_in); REQUIRE(rdata->type == dns_rdatatype_srv); - REQUIRE(srv != NULL); REQUIRE(rdata->length != 0); + srv = target; + srv->common.rdclass = rdata->rdclass; srv->common.rdtype = rdata->type; ISC_LINK_INIT(&srv->common, link); @@ -277,11 +281,15 @@ tostruct_in_srv(ARGS_TOSTRUCT) { static inline void freestruct_in_srv(ARGS_FREESTRUCT) { - dns_rdata_in_srv_t *srv = source; + dns_rdata_in_srv_t *srv; + + REQUIRE(((dns_rdata_in_srv_t *)source) != NULL); + REQUIRE(((dns_rdata_in_srv_t *)source)->common.rdtype == + dns_rdatatype_srv); + REQUIRE(((dns_rdata_in_srv_t *)source)->common.rdclass == + dns_rdataclass_in); - REQUIRE(srv != NULL); - REQUIRE(srv->common.rdclass == dns_rdataclass_in); - REQUIRE(srv->common.rdtype == dns_rdatatype_srv); + srv = source; if (srv->mctx == NULL) return; diff --git a/lib/dns/rdata/in_1/wks_11.c b/lib/dns/rdata/in_1/wks_11.c index 130301618e7..8ad0bf6ea1b 100644 --- a/lib/dns/rdata/in_1/wks_11.c +++ b/lib/dns/rdata/in_1/wks_11.c @@ -290,16 +290,19 @@ compare_in_wks(ARGS_COMPARE) { static inline isc_result_t fromstruct_in_wks(ARGS_FROMSTRUCT) { - dns_rdata_in_wks_t *wks = source; + dns_rdata_in_wks_t *wks; uint32_t a; REQUIRE(type == dns_rdatatype_wks); REQUIRE(rdclass == dns_rdataclass_in); - REQUIRE(wks != NULL); - REQUIRE(wks->common.rdtype == type); - REQUIRE(wks->common.rdclass == rdclass); - REQUIRE((wks->map != NULL && wks->map_len <= 8*1024) || - wks->map_len == 0); + REQUIRE(((dns_rdata_in_wks_t *)source) != NULL); + REQUIRE(((dns_rdata_in_wks_t *)source)->common.rdtype == type); + REQUIRE(((dns_rdata_in_wks_t *)source)->common.rdclass == rdclass); + REQUIRE((((dns_rdata_in_wks_t *)source)->map != NULL && + ((dns_rdata_in_wks_t *)source)->map_len <= 8*1024) || + ((dns_rdata_in_wks_t *)source)->map_len == 0); + + wks = source; UNUSED(type); UNUSED(rdclass); @@ -312,15 +315,17 @@ fromstruct_in_wks(ARGS_FROMSTRUCT) { static inline isc_result_t tostruct_in_wks(ARGS_TOSTRUCT) { - dns_rdata_in_wks_t *wks = target; + dns_rdata_in_wks_t *wks; uint32_t n; isc_region_t region; - REQUIRE(wks != NULL); + REQUIRE(((dns_rdata_in_wks_t *)target) != NULL); REQUIRE(rdata->type == dns_rdatatype_wks); REQUIRE(rdata->rdclass == dns_rdataclass_in); REQUIRE(rdata->length != 0); + wks = target; + wks->common.rdclass = rdata->rdclass; wks->common.rdtype = rdata->type; ISC_LINK_INIT(&wks->common, link); @@ -341,11 +346,15 @@ tostruct_in_wks(ARGS_TOSTRUCT) { static inline void freestruct_in_wks(ARGS_FREESTRUCT) { - dns_rdata_in_wks_t *wks = source; + dns_rdata_in_wks_t *wks; + + REQUIRE(((dns_rdata_in_wks_t *)source) != NULL); + REQUIRE(((dns_rdata_in_wks_t *)source)->common.rdtype == + dns_rdatatype_wks); + REQUIRE(((dns_rdata_in_wks_t *)source)->common.rdclass == + dns_rdataclass_in); - REQUIRE(wks != NULL); - REQUIRE(wks->common.rdtype == dns_rdatatype_wks); - REQUIRE(wks->common.rdclass == dns_rdataclass_in); + wks = source; if (wks->mctx == NULL) return; -- 2.47.3