REQUIRE(type == dns_rdatatype_tsig);
REQUIRE(rdclass == dns_rdataclass_any);
- REQUIRE(source != NULL);
+ REQUIRE(tsig != NULL);
REQUIRE(tsig->common.rdclass == rdclass);
REQUIRE(tsig->common.rdtype == type);
freestruct_any_tsig(ARGS_FREESTRUCT) {
dns_rdata_any_tsig_t *tsig = (dns_rdata_any_tsig_t *) source;
- REQUIRE(source != NULL);
+ REQUIRE(tsig != NULL);
REQUIRE(tsig->common.rdtype == dns_rdatatype_tsig);
REQUIRE(tsig->common.rdclass == dns_rdataclass_any);
isc_region_t region;
REQUIRE(type == dns_rdatatype_a);
- REQUIRE(source != NULL);
+ REQUIRE(a != NULL);
REQUIRE(a->common.rdtype == type);
REQUIRE(a->common.rdclass == rdclass);
freestruct_ch_a(ARGS_FREESTRUCT) {
dns_rdata_ch_a_t *a = source;
- REQUIRE(source != NULL);
+ REQUIRE(a != NULL);
REQUIRE(a->common.rdtype == dns_rdatatype_a);
if (a->mctx == NULL)
isc_region_t region;
REQUIRE(type == dns_rdatatype_afsdb);
- REQUIRE(source != NULL);
+ REQUIRE(afsdb != NULL);
REQUIRE(afsdb->common.rdclass == rdclass);
REQUIRE(afsdb->common.rdtype == type);
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_afsdb);
- REQUIRE(target != NULL);
+ REQUIRE(afsdb != NULL);
REQUIRE(rdata->length != 0);
afsdb->common.rdclass = rdata->rdclass;
freestruct_afsdb(ARGS_FREESTRUCT) {
dns_rdata_afsdb_t *afsdb = source;
- REQUIRE(source != NULL);
+ REQUIRE(afsdb != NULL);
REQUIRE(afsdb->common.rdtype == dns_rdatatype_afsdb);
if (afsdb->mctx == NULL)
uint32_t n;
REQUIRE(type == dns_rdatatype_amtrelay);
- REQUIRE(source != NULL);
+ REQUIRE(amtrelay != NULL);
REQUIRE(amtrelay->common.rdtype == type);
REQUIRE(amtrelay->common.rdclass == rdclass);
uint32_t n;
REQUIRE(rdata->type == dns_rdatatype_amtrelay);
- REQUIRE(target != NULL);
+ REQUIRE(amtrelay != NULL);
REQUIRE(rdata->length >= 2);
amtrelay->common.rdclass = rdata->rdclass;
freestruct_amtrelay(ARGS_FREESTRUCT) {
dns_rdata_amtrelay_t *amtrelay = source;
- REQUIRE(source != NULL);
+ REQUIRE(amtrelay != NULL);
REQUIRE(amtrelay->common.rdtype == dns_rdatatype_amtrelay);
if (amtrelay->mctx == NULL)
dns_rdata_avc_t *avc = target;
REQUIRE(rdata->type == dns_rdatatype_avc);
- REQUIRE(target != NULL);
+ REQUIRE(avc != NULL);
avc->common.rdclass = rdata->rdclass;
avc->common.rdtype = rdata->type;
static inline void
freestruct_avc(ARGS_FREESTRUCT) {
- dns_rdata_avc_t *txt = source;
+ dns_rdata_avc_t *avc = source;
- REQUIRE(source != NULL);
- REQUIRE(txt->common.rdtype == dns_rdatatype_avc);
+ REQUIRE(avc != NULL);
+ REQUIRE(avc->common.rdtype == dns_rdatatype_avc);
generic_freestruct_txt(source);
}
unsigned int i;
REQUIRE(type == dns_rdatatype_caa);
- REQUIRE(source != NULL);
+ REQUIRE(caa != NULL);
REQUIRE(caa->common.rdtype == type);
REQUIRE(caa->common.rdclass == rdclass);
REQUIRE(caa->tag != NULL && caa->tag_len != 0);
isc_region_t sr;
REQUIRE(rdata->type == dns_rdatatype_caa);
- REQUIRE(target != NULL);
+ REQUIRE(caa != NULL);
REQUIRE(rdata->length >= 3U);
REQUIRE(rdata->data != NULL);
freestruct_caa(ARGS_FREESTRUCT) {
dns_rdata_caa_t *caa = (dns_rdata_caa_t *) source;
- REQUIRE(source != NULL);
+ REQUIRE(caa != NULL);
REQUIRE(caa->common.rdtype == dns_rdatatype_caa);
if (caa->mctx == NULL)
dns_rdata_cds_t *cds = target;
REQUIRE(rdata->type == dns_rdatatype_cds);
- REQUIRE(target != NULL);
+ REQUIRE(cds != NULL);
REQUIRE(rdata->length != 0);
/*
static inline void
freestruct_cds(ARGS_FREESTRUCT) {
- dns_rdata_cds_t *ds = source;
+ dns_rdata_cds_t *cds = source;
- REQUIRE(ds != NULL);
- REQUIRE(ds->common.rdtype == dns_rdatatype_cds);
+ REQUIRE(cds != NULL);
+ REQUIRE(cds->common.rdtype == dns_rdatatype_cds);
- if (ds->mctx == NULL)
+ if (cds->mctx == NULL) {
return;
+ }
- if (ds->digest != NULL)
- isc_mem_free(ds->mctx, ds->digest);
- ds->mctx = NULL;
+ if (cds->digest != NULL) {
+ isc_mem_free(cds->mctx, cds->digest);
+ }
+ cds->mctx = NULL;
}
static inline isc_result_t
dns_rdata_cert_t *cert = source;
REQUIRE(type == dns_rdatatype_cert);
- REQUIRE(source != NULL);
+ REQUIRE(cert != NULL);
REQUIRE(cert->common.rdtype == type);
REQUIRE(cert->common.rdclass == rdclass);
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_cert);
- REQUIRE(target != NULL);
+ REQUIRE(cert != NULL);
REQUIRE(rdata->length != 0);
cert->common.rdclass = rdata->rdclass;
isc_region_t region;
REQUIRE(type == dns_rdatatype_cname);
- REQUIRE(source != NULL);
+ REQUIRE(cname != NULL);
REQUIRE(cname->common.rdtype == type);
REQUIRE(cname->common.rdclass == rdclass);
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_cname);
- REQUIRE(target != NULL);
+ REQUIRE(cname != NULL);
REQUIRE(rdata->length != 0);
cname->common.rdclass = rdata->rdclass;
freestruct_cname(ARGS_FREESTRUCT) {
dns_rdata_cname_t *cname = source;
- REQUIRE(source != NULL);
+ REQUIRE(cname != NULL);
if (cname->mctx == NULL)
return;
isc_region_t region;
REQUIRE(type == dns_rdatatype_csync);
- REQUIRE(source != NULL);
+ REQUIRE(csync != NULL);
REQUIRE(csync->common.rdtype == type);
REQUIRE(csync->common.rdclass == rdclass);
REQUIRE(csync->typebits != NULL || csync->len == 0);
dns_rdata_csync_t *csync = target;
REQUIRE(rdata->type == dns_rdatatype_csync);
- REQUIRE(target != NULL);
+ REQUIRE(csync != NULL);
REQUIRE(rdata->length != 0);
csync->common.rdclass = rdata->rdclass;
freestruct_csync(ARGS_FREESTRUCT) {
dns_rdata_csync_t *csync = source;
- REQUIRE(source != NULL);
+ REQUIRE(csync != NULL);
REQUIRE(csync->common.rdtype == dns_rdatatype_csync);
if (csync->mctx == NULL)
dns_rdata_dlv_t *dlv = target;
REQUIRE(rdata->type == dns_rdatatype_dlv);
+ REQUIRE(dlv != NULL);
dlv->common.rdclass = rdata->rdclass;
dlv->common.rdtype = rdata->type;
isc_region_t region;
REQUIRE(type == dns_rdatatype_dname);
- REQUIRE(source != NULL);
+ REQUIRE(dname != NULL);
REQUIRE(dname->common.rdtype == type);
REQUIRE(dname->common.rdclass == rdclass);
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_dname);
- REQUIRE(target != NULL);
+ REQUIRE(dname != NULL);
REQUIRE(rdata->length != 0);
dname->common.rdclass = rdata->rdclass;
freestruct_dname(ARGS_FREESTRUCT) {
dns_rdata_dname_t *dname = source;
- REQUIRE(source != NULL);
+ REQUIRE(dname != NULL);
REQUIRE(dname->common.rdtype == dns_rdatatype_dname);
if (dname->mctx == NULL)
dns_rdata_doa_t *doa = source;
REQUIRE(type == dns_rdatatype_doa);
- REQUIRE(source != NULL);
+ REQUIRE(doa != NULL);
REQUIRE(doa->common.rdtype == dns_rdatatype_doa);
REQUIRE(doa->common.rdclass == rdclass);
REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_doa);
+ REQUIRE(doa != NULL);
REQUIRE(rdata->length != 0);
doa->common.rdclass = rdata->rdclass;
freestruct_doa(ARGS_FREESTRUCT) {
dns_rdata_doa_t *doa = source;
- REQUIRE(source != NULL);
+ REQUIRE(doa != NULL);
REQUIRE(doa->common.rdtype == dns_rdatatype_doa);
if (doa->mctx == NULL) {
generic_fromstruct_ds(ARGS_FROMSTRUCT) {
dns_rdata_ds_t *ds = source;
- REQUIRE(source != NULL);
+ REQUIRE(ds != NULL);
REQUIRE(ds->common.rdtype == type);
REQUIRE(ds->common.rdclass == rdclass);
dns_rdata_ds_t *ds = target;
isc_region_t region;
- REQUIRE(target != NULL);
+ REQUIRE(ds != NULL);
REQUIRE(rdata->length != 0);
REQUIRE(ds->common.rdtype == rdata->type);
REQUIRE(ds->common.rdclass == rdata->rdclass);
dns_rdata_ds_t *ds = target;
REQUIRE(rdata->type == dns_rdatatype_ds);
- REQUIRE(target != NULL);
+ REQUIRE(ds != NULL);
ds->common.rdclass = rdata->rdclass;
ds->common.rdtype = rdata->type;
dns_rdata_eui48_t *eui48 = source;
REQUIRE(type == dns_rdatatype_eui48);
- REQUIRE(source != NULL);
+ REQUIRE(eui48 != NULL);
REQUIRE(eui48->common.rdtype == type);
REQUIRE(eui48->common.rdclass == rdclass);
dns_rdata_eui48_t *eui48 = target;
REQUIRE(rdata->type == dns_rdatatype_eui48);
- REQUIRE(target != NULL);
+ REQUIRE(eui48 != NULL);
REQUIRE(rdata->length == 6);
UNUSED(mctx);
freestruct_eui48(ARGS_FREESTRUCT) {
dns_rdata_eui48_t *eui48 = source;
- REQUIRE(source != NULL);
+ REQUIRE(eui48 != NULL);
REQUIRE(eui48->common.rdtype == dns_rdatatype_eui48);
return;
dns_rdata_eui64_t *eui64 = source;
REQUIRE(type == dns_rdatatype_eui64);
- REQUIRE(source != NULL);
+ REQUIRE(eui64 != NULL);
REQUIRE(eui64->common.rdtype == type);
REQUIRE(eui64->common.rdclass == rdclass);
dns_rdata_eui64_t *eui64 = target;
REQUIRE(rdata->type == dns_rdatatype_eui64);
- REQUIRE(target != NULL);
+ REQUIRE(eui64 != NULL);
REQUIRE(rdata->length == 8);
UNUSED(mctx);
freestruct_eui64(ARGS_FREESTRUCT) {
dns_rdata_eui64_t *eui64 = source;
- REQUIRE(source != NULL);
+ REQUIRE(eui64 != NULL);
REQUIRE(eui64->common.rdtype == dns_rdatatype_eui64);
return;
dns_rdata_gpos_t *gpos = source;
REQUIRE(type == dns_rdatatype_gpos);
- REQUIRE(source != NULL);
+ REQUIRE(gpos != NULL);
REQUIRE(gpos->common.rdtype == type);
REQUIRE(gpos->common.rdclass == rdclass);
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_gpos);
- REQUIRE(target != NULL);
+ REQUIRE(gpos != NULL);
REQUIRE(rdata->length != 0);
gpos->common.rdclass = rdata->rdclass;
freestruct_gpos(ARGS_FREESTRUCT) {
dns_rdata_gpos_t *gpos = source;
- REQUIRE(source != NULL);
+ REQUIRE(gpos != NULL);
REQUIRE(gpos->common.rdtype == dns_rdatatype_gpos);
if (gpos->mctx == NULL)
dns_rdata_hinfo_t *hinfo = source;
REQUIRE(type == dns_rdatatype_hinfo);
- REQUIRE(source != NULL);
+ REQUIRE(hinfo != NULL);
REQUIRE(hinfo->common.rdtype == type);
REQUIRE(hinfo->common.rdclass == rdclass);
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_hinfo);
- REQUIRE(target != NULL);
+ REQUIRE(hinfo != NULL);
REQUIRE(rdata->length != 0);
hinfo->common.rdclass = rdata->rdclass;
freestruct_hinfo(ARGS_FREESTRUCT) {
dns_rdata_hinfo_t *hinfo = source;
- REQUIRE(source != NULL);
+ REQUIRE(hinfo != NULL);
if (hinfo->mctx == NULL)
return;
isc_result_t result;
REQUIRE(type == dns_rdatatype_hip);
- REQUIRE(source != NULL);
+ REQUIRE(hip != NULL);
REQUIRE(hip->common.rdtype == type);
REQUIRE(hip->common.rdclass == rdclass);
REQUIRE(hip->hit_len > 0 && hip->hit != NULL);
dns_rdata_hip_t *hip = target;
REQUIRE(rdata->type == dns_rdatatype_hip);
- REQUIRE(target != NULL);
+ REQUIRE(hip != NULL);
REQUIRE(rdata->length != 0);
hip->common.rdclass = rdata->rdclass;
freestruct_hip(ARGS_FREESTRUCT) {
dns_rdata_hip_t *hip = source;
- REQUIRE(source != NULL);
+ REQUIRE(hip != NULL);
if (hip->mctx == NULL)
return;
uint32_t n;
REQUIRE(type == dns_rdatatype_ipseckey);
- REQUIRE(source != NULL);
+ REQUIRE(ipseckey != NULL);
REQUIRE(ipseckey->common.rdtype == type);
REQUIRE(ipseckey->common.rdclass == rdclass);
uint32_t n;
REQUIRE(rdata->type == dns_rdatatype_ipseckey);
- REQUIRE(target != NULL);
+ REQUIRE(ipseckey != NULL);
REQUIRE(rdata->length >= 3);
if (rdata->data[1] > 3U)
freestruct_ipseckey(ARGS_FREESTRUCT) {
dns_rdata_ipseckey_t *ipseckey = source;
- REQUIRE(source != NULL);
+ REQUIRE(ipseckey != NULL);
REQUIRE(ipseckey->common.rdtype == dns_rdatatype_ipseckey);
if (ipseckey->mctx == NULL)
dns_rdata_isdn_t *isdn = source;
REQUIRE(type == dns_rdatatype_isdn);
- REQUIRE(source != NULL);
+ REQUIRE(isdn != NULL);
REQUIRE(isdn->common.rdtype == type);
REQUIRE(isdn->common.rdclass == rdclass);
isc_region_t r;
REQUIRE(rdata->type == dns_rdatatype_isdn);
- REQUIRE(target != NULL);
+ REQUIRE(isdn != NULL);
REQUIRE(rdata->length != 0);
isdn->common.rdclass = rdata->rdclass;
freestruct_isdn(ARGS_FREESTRUCT) {
dns_rdata_isdn_t *isdn = source;
- REQUIRE(source != NULL);
+ REQUIRE(isdn != NULL);
if (isdn->mctx == NULL)
return;
dns_rdata_key_t *key = target;
isc_region_t sr;
- REQUIRE(rdata != NULL);
+ REQUIRE(key != NULL);
REQUIRE(rdata->length != 0);
REQUIRE(key != NULL);
dns_rdata_keydata_t *keydata = source;
REQUIRE(type == dns_rdatatype_keydata);
- REQUIRE(source != NULL);
+ REQUIRE(keydata != NULL);
REQUIRE(keydata->common.rdtype == type);
REQUIRE(keydata->common.rdclass == rdclass);
isc_region_t sr;
REQUIRE(rdata->type == dns_rdatatype_keydata);
- REQUIRE(target != NULL);
+ REQUIRE(keydata != NULL);
keydata->common.rdclass = rdata->rdclass;
keydata->common.rdtype = rdata->type;
freestruct_keydata(ARGS_FREESTRUCT) {
dns_rdata_keydata_t *keydata = (dns_rdata_keydata_t *) source;
- REQUIRE(source != NULL);
+ REQUIRE(keydata != NULL);
REQUIRE(keydata->common.rdtype == dns_rdatatype_keydata);
if (keydata->mctx == NULL)
uint32_t n;
REQUIRE(type == dns_rdatatype_l32);
- REQUIRE(source != NULL);
+ REQUIRE(l32 != NULL);
REQUIRE(l32->common.rdtype == type);
REQUIRE(l32->common.rdclass == rdclass);
uint32_t n;
REQUIRE(rdata->type == dns_rdatatype_l32);
- REQUIRE(target != NULL);
+ REQUIRE(l32 != NULL);
REQUIRE(rdata->length == 6);
UNUSED(mctx);
freestruct_l32(ARGS_FREESTRUCT) {
dns_rdata_l32_t *l32 = source;
- REQUIRE(source != NULL);
+ REQUIRE(l32 != NULL);
REQUIRE(l32->common.rdtype == dns_rdatatype_l32);
return;
dns_rdata_l64_t *l64 = source;
REQUIRE(type == dns_rdatatype_l64);
- REQUIRE(source != NULL);
+ REQUIRE(l64 != NULL);
REQUIRE(l64->common.rdtype == type);
REQUIRE(l64->common.rdclass == rdclass);
dns_rdata_l64_t *l64 = target;
REQUIRE(rdata->type == dns_rdatatype_l64);
- REQUIRE(target != NULL);
+ REQUIRE(l64 != NULL);
REQUIRE(rdata->length == 10);
UNUSED(mctx);
freestruct_l64(ARGS_FREESTRUCT) {
dns_rdata_l64_t *l64 = source;
- REQUIRE(source != NULL);
+ REQUIRE(l64 != NULL);
REQUIRE(l64->common.rdtype == dns_rdatatype_l64);
return;
uint8_t c;
REQUIRE(type == dns_rdatatype_loc);
- REQUIRE(source != NULL);
+ REQUIRE(loc != NULL);
REQUIRE(loc->common.rdtype == type);
REQUIRE(loc->common.rdclass == rdclass);
uint8_t version;
REQUIRE(rdata->type == dns_rdatatype_loc);
- REQUIRE(target != NULL);
+ REQUIRE(loc != NULL);
REQUIRE(rdata->length != 0);
UNUSED(mctx);
freestruct_loc(ARGS_FREESTRUCT) {
dns_rdata_loc_t *loc = source;
- REQUIRE(source != NULL);
+ REQUIRE(loc != NULL);
REQUIRE(loc->common.rdtype == dns_rdatatype_loc);
UNUSED(source);
isc_region_t region;
REQUIRE(type == dns_rdatatype_lp);
- REQUIRE(source != NULL);
+ REQUIRE(lp != NULL);
REQUIRE(lp->common.rdtype == type);
REQUIRE(lp->common.rdclass == rdclass);
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_lp);
- REQUIRE(target != NULL);
+ REQUIRE(lp != NULL);
REQUIRE(rdata->length != 0);
lp->common.rdclass = rdata->rdclass;
freestruct_lp(ARGS_FREESTRUCT) {
dns_rdata_lp_t *lp = source;
- REQUIRE(source != NULL);
+ REQUIRE(lp != NULL);
REQUIRE(lp->common.rdtype == dns_rdatatype_lp);
if (lp->mctx == NULL)
isc_region_t region;
REQUIRE(type == dns_rdatatype_mb);
- REQUIRE(source != NULL);
+ REQUIRE(mb != NULL);
REQUIRE(mb->common.rdtype == type);
REQUIRE(mb->common.rdclass == rdclass);
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_mb);
- REQUIRE(target != NULL);
+ REQUIRE(mb != NULL);
REQUIRE(rdata->length != 0);
mb->common.rdclass = rdata->rdclass;
freestruct_mb(ARGS_FREESTRUCT) {
dns_rdata_mb_t *mb = source;
- REQUIRE(source != NULL);
+ REQUIRE(mb != NULL);
if (mb->mctx == NULL)
return;
isc_region_t region;
REQUIRE(type == dns_rdatatype_md);
- REQUIRE(source != NULL);
+ REQUIRE(md != NULL);
REQUIRE(md->common.rdtype == type);
REQUIRE(md->common.rdclass == rdclass);
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_md);
- REQUIRE(target != NULL);
+ REQUIRE(md != NULL);
REQUIRE(rdata->length != 0);
md->common.rdclass = rdata->rdclass;
freestruct_md(ARGS_FREESTRUCT) {
dns_rdata_md_t *md = source;
- REQUIRE(source != NULL);
+ REQUIRE(md != NULL);
REQUIRE(md->common.rdtype == dns_rdatatype_md);
if (md->mctx == NULL)
isc_region_t region;
REQUIRE(type == dns_rdatatype_mf);
- REQUIRE(source != NULL);
+ REQUIRE(mf != NULL);
REQUIRE(mf->common.rdtype == type);
REQUIRE(mf->common.rdclass == rdclass);
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_mf);
- REQUIRE(target != NULL);
+ REQUIRE(mf != NULL);
REQUIRE(rdata->length != 0);
mf->common.rdclass = rdata->rdclass;
freestruct_mf(ARGS_FREESTRUCT) {
dns_rdata_mf_t *mf = source;
- REQUIRE(source != NULL);
+ REQUIRE(mf != NULL);
REQUIRE(mf->common.rdtype == dns_rdatatype_mf);
if (mf->mctx == NULL)
isc_region_t region;
REQUIRE(type == dns_rdatatype_mg);
- REQUIRE(source != NULL);
+ REQUIRE(mg != NULL);
REQUIRE(mg->common.rdtype == type);
REQUIRE(mg->common.rdclass == rdclass);
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_mg);
- REQUIRE(target != NULL);
+ REQUIRE(mg != NULL);
REQUIRE(rdata->length != 0);
mg->common.rdclass = rdata->rdclass;
freestruct_mg(ARGS_FREESTRUCT) {
dns_rdata_mg_t *mg = source;
- REQUIRE(source != NULL);
+ REQUIRE(mg != NULL);
REQUIRE(mg->common.rdtype == dns_rdatatype_mg);
if (mg->mctx == NULL)
isc_region_t region;
REQUIRE(type == dns_rdatatype_minfo);
- REQUIRE(source != NULL);
+ REQUIRE(minfo != NULL);
REQUIRE(minfo->common.rdtype == type);
REQUIRE(minfo->common.rdclass == rdclass);
isc_result_t result;
REQUIRE(rdata->type == dns_rdatatype_minfo);
- REQUIRE(target != NULL);
+ REQUIRE(minfo != NULL);
REQUIRE(rdata->length != 0);
minfo->common.rdclass = rdata->rdclass;
freestruct_minfo(ARGS_FREESTRUCT) {
dns_rdata_minfo_t *minfo = source;
- REQUIRE(source != NULL);
+ REQUIRE(minfo != NULL);
REQUIRE(minfo->common.rdtype == dns_rdatatype_minfo);
if (minfo->mctx == NULL)
isc_region_t region;
REQUIRE(type == dns_rdatatype_mr);
- REQUIRE(source != NULL);
+ REQUIRE(mr != NULL);
REQUIRE(mr->common.rdtype == type);
REQUIRE(mr->common.rdclass == rdclass);
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_mr);
- REQUIRE(target != NULL);
+ REQUIRE(mr != NULL);
REQUIRE(rdata->length != 0);
mr->common.rdclass = rdata->rdclass;
freestruct_mr(ARGS_FREESTRUCT) {
dns_rdata_mr_t *mr = source;
- REQUIRE(source != NULL);
+ REQUIRE(mr != NULL);
REQUIRE(mr->common.rdtype == dns_rdatatype_mr);
if (mr->mctx == NULL)
isc_region_t region;
REQUIRE(type == dns_rdatatype_mx);
- REQUIRE(source != NULL);
+ REQUIRE(mx != NULL);
REQUIRE(mx->common.rdtype == type);
REQUIRE(mx->common.rdclass == rdclass);
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_mx);
- REQUIRE(target != NULL);
+ REQUIRE(mx != NULL);
REQUIRE(rdata->length != 0);
mx->common.rdclass = rdata->rdclass;
freestruct_mx(ARGS_FREESTRUCT) {
dns_rdata_mx_t *mx = source;
- REQUIRE(source != NULL);
+ REQUIRE(mx != NULL);
REQUIRE(mx->common.rdtype == dns_rdatatype_mx);
if (mx->mctx == NULL)
isc_region_t region;
REQUIRE(type == dns_rdatatype_naptr);
- REQUIRE(source != NULL);
+ REQUIRE(naptr != NULL);
REQUIRE(naptr->common.rdtype == type);
REQUIRE(naptr->common.rdclass == rdclass);
REQUIRE(naptr->flags != NULL || naptr->flags_len == 0);
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_naptr);
- REQUIRE(target != NULL);
+ REQUIRE(naptr != NULL);
REQUIRE(rdata->length != 0);
naptr->common.rdclass = rdata->rdclass;
freestruct_naptr(ARGS_FREESTRUCT) {
dns_rdata_naptr_t *naptr = source;
- REQUIRE(source != NULL);
+ REQUIRE(naptr != NULL);
REQUIRE(naptr->common.rdtype == dns_rdatatype_naptr);
if (naptr->mctx == NULL)
dns_rdata_nid_t *nid = source;
REQUIRE(type == dns_rdatatype_nid);
- REQUIRE(source != NULL);
+ REQUIRE(nid != NULL);
REQUIRE(nid->common.rdtype == type);
REQUIRE(nid->common.rdclass == rdclass);
dns_rdata_nid_t *nid = target;
REQUIRE(rdata->type == dns_rdatatype_nid);
- REQUIRE(target != NULL);
+ REQUIRE(nid != NULL);
REQUIRE(rdata->length == 10);
UNUSED(mctx);
freestruct_nid(ARGS_FREESTRUCT) {
dns_rdata_nid_t *nid = source;
- REQUIRE(source != NULL);
+ REQUIRE(nid != NULL);
REQUIRE(nid->common.rdtype == dns_rdatatype_nid);
return;
static inline isc_result_t
tostruct_ninfo(ARGS_TOSTRUCT) {
- dns_rdata_ninfo_t *txt = target;
+ dns_rdata_ninfo_t *ninfo = target;
REQUIRE(rdata->type == dns_rdatatype_ninfo);
+ REQUIRE(ninfo != NULL);
- txt->common.rdclass = rdata->rdclass;
- txt->common.rdtype = rdata->type;
- ISC_LINK_INIT(&txt->common, link);
+ ninfo->common.rdclass = rdata->rdclass;
+ ninfo->common.rdtype = rdata->type;
+ ISC_LINK_INIT(&ninfo->common, link);
return (generic_tostruct_txt(rdata, target, mctx));
}
freestruct_ninfo(ARGS_FREESTRUCT) {
dns_rdata_ninfo_t *ninfo = source;
- REQUIRE(source != NULL);
+ REQUIRE(ninfo != NULL);
REQUIRE(ninfo->common.rdtype == dns_rdatatype_ninfo);
generic_freestruct_txt(source);
isc_region_t region;
REQUIRE(type == dns_rdatatype_ns);
- REQUIRE(source != NULL);
+ REQUIRE(ns != NULL);
REQUIRE(ns->common.rdtype == type);
REQUIRE(ns->common.rdclass == rdclass);
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_ns);
- REQUIRE(target != NULL);
+ REQUIRE(ns != NULL);
REQUIRE(rdata->length != 0);
ns->common.rdclass = rdata->rdclass;
freestruct_ns(ARGS_FREESTRUCT) {
dns_rdata_ns_t *ns = source;
- REQUIRE(source != NULL);
+ REQUIRE(ns != NULL);
if (ns->mctx == NULL)
return;
isc_region_t region;
REQUIRE(type == dns_rdatatype_nsec3);
- REQUIRE(source != NULL);
+ REQUIRE(nsec3 != NULL);
REQUIRE(nsec3->common.rdtype == type);
REQUIRE(nsec3->common.rdclass == rdclass);
REQUIRE(nsec3->typebits != NULL || nsec3->len == 0);
dns_rdata_nsec3_t *nsec3 = target;
REQUIRE(rdata->type == dns_rdatatype_nsec3);
- REQUIRE(target != NULL);
+ REQUIRE(nsec3 != NULL);
REQUIRE(rdata->length != 0);
nsec3->common.rdclass = rdata->rdclass;
freestruct_nsec3(ARGS_FREESTRUCT) {
dns_rdata_nsec3_t *nsec3 = source;
- REQUIRE(source != NULL);
+ REQUIRE(nsec3 != NULL);
REQUIRE(nsec3->common.rdtype == dns_rdatatype_nsec3);
if (nsec3->mctx == NULL)
dns_rdata_nsec3param_t *nsec3param = source;
REQUIRE(type == dns_rdatatype_nsec3param);
- REQUIRE(source != NULL);
+ REQUIRE(nsec3param != NULL);
REQUIRE(nsec3param->common.rdtype == type);
REQUIRE(nsec3param->common.rdclass == rdclass);
dns_rdata_nsec3param_t *nsec3param = target;
REQUIRE(rdata->type == dns_rdatatype_nsec3param);
- REQUIRE(target != NULL);
+ REQUIRE(nsec3param != NULL);
REQUIRE(rdata->length != 0);
nsec3param->common.rdclass = rdata->rdclass;
freestruct_nsec3param(ARGS_FREESTRUCT) {
dns_rdata_nsec3param_t *nsec3param = source;
- REQUIRE(source != NULL);
+ REQUIRE(nsec3param != NULL);
REQUIRE(nsec3param->common.rdtype == dns_rdatatype_nsec3param);
if (nsec3param->mctx == NULL)
isc_region_t region;
REQUIRE(type == dns_rdatatype_nsec);
- REQUIRE(source != NULL);
+ REQUIRE(nsec != NULL);
REQUIRE(nsec->common.rdtype == type);
REQUIRE(nsec->common.rdclass == rdclass);
REQUIRE(nsec->typebits != NULL || nsec->len == 0);
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_nsec);
- REQUIRE(target != NULL);
+ REQUIRE(nsec != NULL);
REQUIRE(rdata->length != 0);
nsec->common.rdclass = rdata->rdclass;
freestruct_nsec(ARGS_FREESTRUCT) {
dns_rdata_nsec_t *nsec = source;
- REQUIRE(source != NULL);
+ REQUIRE(nsec != NULL);
REQUIRE(nsec->common.rdtype == dns_rdatatype_nsec);
if (nsec->mctx == NULL)
dns_rdata_null_t *null = source;
REQUIRE(type == dns_rdatatype_null);
- REQUIRE(source != NULL);
+ REQUIRE(null != NULL);
REQUIRE(null->common.rdtype == type);
REQUIRE(null->common.rdclass == rdclass);
REQUIRE(null->data != NULL || null->length == 0);
isc_region_t r;
REQUIRE(rdata->type == dns_rdatatype_null);
- REQUIRE(target != NULL);
+ REQUIRE(null != NULL);
null->common.rdclass = rdata->rdclass;
null->common.rdtype = rdata->type;
freestruct_null(ARGS_FREESTRUCT) {
dns_rdata_null_t *null = source;
- REQUIRE(source != NULL);
+ REQUIRE(null != NULL);
REQUIRE(null->common.rdtype == dns_rdatatype_null);
if (null->mctx == NULL)
isc_region_t region;
REQUIRE(type == dns_rdatatype_nxt);
- REQUIRE(source != NULL);
+ REQUIRE(nxt != NULL);
REQUIRE(nxt->common.rdtype == type);
REQUIRE(nxt->common.rdclass == rdclass);
REQUIRE(nxt->typebits != NULL || nxt->len == 0);
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_nxt);
- REQUIRE(target != NULL);
+ REQUIRE(nxt != NULL);
REQUIRE(rdata->length != 0);
nxt->common.rdclass = rdata->rdclass;
freestruct_nxt(ARGS_FREESTRUCT) {
dns_rdata_nxt_t *nxt = source;
- REQUIRE(source != NULL);
+ REQUIRE(nxt != NULL);
REQUIRE(nxt->common.rdtype == dns_rdatatype_nxt);
if (nxt->mctx == NULL)
dns_rdata_openpgpkey_t *sig = source;
REQUIRE(type == dns_rdatatype_openpgpkey);
- REQUIRE(source != NULL);
+ REQUIRE(sig != NULL);
REQUIRE(sig->common.rdtype == type);
REQUIRE(sig->common.rdclass == rdclass);
REQUIRE(sig->keyring != NULL && sig->length != 0);
dns_rdata_openpgpkey_t *sig = target;
REQUIRE(rdata->type == dns_rdatatype_openpgpkey);
- REQUIRE(target != NULL);
+ REQUIRE(sig != NULL);
REQUIRE(rdata->length != 0);
sig->common.rdclass = rdata->rdclass;
freestruct_openpgpkey(ARGS_FREESTRUCT) {
dns_rdata_openpgpkey_t *sig = (dns_rdata_openpgpkey_t *) source;
- REQUIRE(source != NULL);
+ REQUIRE(sig != NULL);
REQUIRE(sig->common.rdtype == dns_rdatatype_openpgpkey);
if (sig->mctx == NULL)
uint16_t length;
REQUIRE(type == dns_rdatatype_opt);
- REQUIRE(source != NULL);
+ REQUIRE(opt != NULL);
REQUIRE(opt->common.rdtype == type);
REQUIRE(opt->common.rdclass == rdclass);
REQUIRE(opt->options != NULL || opt->length == 0);
isc_region_t r;
REQUIRE(rdata->type == dns_rdatatype_opt);
- REQUIRE(target != NULL);
+ REQUIRE(opt != NULL);
opt->common.rdclass = rdata->rdclass;
opt->common.rdtype = rdata->type;
freestruct_opt(ARGS_FREESTRUCT) {
dns_rdata_opt_t *opt = source;
- REQUIRE(source != NULL);
+ REQUIRE(opt != NULL);
REQUIRE(opt->common.rdtype == dns_rdatatype_opt);
if (opt->mctx == NULL)
REQUIRE(type == dns_rdatatype_proforma.c#);
REQUIRE(rdclass == #);
- REQUIRE(source != NULL);
+ REQUIRE(# != NULL);
REQUIRE(#->common.rdtype == dns_rdatatype_proforma.ctype);
REQUIRE(#->common.rdclass == rdclass);
freestruct_#(ARGS_FREESTRUCT) {
dns_rdata_#_t *# = source;
- REQUIRE(source != NULL);
+ REQUIRE(# != NULL);
REQUIRE(#->common.rdtype == dns_rdatatype_proforma.c#);
REQUIRE(#->common.rdclass == #);
isc_region_t region;
REQUIRE(type == dns_rdatatype_ptr);
- REQUIRE(source != NULL);
+ REQUIRE(ptr != NULL);
REQUIRE(ptr->common.rdtype == type);
REQUIRE(ptr->common.rdclass == rdclass);
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_ptr);
- REQUIRE(target != NULL);
+ REQUIRE(ptr != NULL);
REQUIRE(rdata->length != 0);
ptr->common.rdclass = rdata->rdclass;
freestruct_ptr(ARGS_FREESTRUCT) {
dns_rdata_ptr_t *ptr = source;
- REQUIRE(source != NULL);
+ REQUIRE(ptr != NULL);
REQUIRE(ptr->common.rdtype == dns_rdatatype_ptr);
if (ptr->mctx == NULL)
isc_region_t region;
REQUIRE(type == dns_rdatatype_rp);
- REQUIRE(source != NULL);
+ REQUIRE(rp != NULL);
REQUIRE(rp->common.rdtype == type);
REQUIRE(rp->common.rdclass == rdclass);
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_rp);
- REQUIRE(target != NULL);
+ REQUIRE(rp != NULL);
REQUIRE(rdata->length != 0);
rp->common.rdclass = rdata->rdclass;
freestruct_rp(ARGS_FREESTRUCT) {
dns_rdata_rp_t *rp = source;
- REQUIRE(source != NULL);
+ REQUIRE(rp != NULL);
REQUIRE(rp->common.rdtype == dns_rdatatype_rp);
if (rp->mctx == NULL)
dns_rdata_rrsig_t *sig = source;
REQUIRE(type == dns_rdatatype_rrsig);
- REQUIRE(source != NULL);
+ REQUIRE(sig != NULL);
REQUIRE(sig->common.rdtype == type);
REQUIRE(sig->common.rdclass == rdclass);
REQUIRE(sig->signature != NULL || sig->siglen == 0);
dns_name_t signer;
REQUIRE(rdata->type == dns_rdatatype_rrsig);
- REQUIRE(target != NULL);
+ REQUIRE(sig != NULL);
REQUIRE(rdata->length != 0);
sig->common.rdclass = rdata->rdclass;
freestruct_rrsig(ARGS_FREESTRUCT) {
dns_rdata_rrsig_t *sig = (dns_rdata_rrsig_t *) source;
- REQUIRE(source != NULL);
+ REQUIRE(sig != NULL);
REQUIRE(sig->common.rdtype == dns_rdatatype_rrsig);
if (sig->mctx == NULL)
isc_region_t region;
REQUIRE(type == dns_rdatatype_rt);
- REQUIRE(source != NULL);
+ REQUIRE(rt != NULL);
REQUIRE(rt->common.rdtype == type);
REQUIRE(rt->common.rdclass == rdclass);
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_rt);
- REQUIRE(target != NULL);
+ REQUIRE(rt != NULL);
REQUIRE(rdata->length != 0);
rt->common.rdclass = rdata->rdclass;
freestruct_rt(ARGS_FREESTRUCT) {
dns_rdata_rt_t *rt = source;
- REQUIRE(source != NULL);
+ REQUIRE(rt != NULL);
REQUIRE(rt->common.rdtype == dns_rdatatype_rt);
if (rt->mctx == NULL)
dns_rdata_sig_t *sig = source;
REQUIRE(type == dns_rdatatype_sig);
- REQUIRE(source != NULL);
+ REQUIRE(sig != NULL);
REQUIRE(sig->common.rdtype == type);
REQUIRE(sig->common.rdclass == rdclass);
REQUIRE(sig->signature != NULL || sig->siglen == 0);
dns_name_t signer;
REQUIRE(rdata->type == dns_rdatatype_sig);
- REQUIRE(target != NULL);
+ REQUIRE(sig != NULL);
REQUIRE(rdata->length != 0);
sig->common.rdclass = rdata->rdclass;
freestruct_sig(ARGS_FREESTRUCT) {
dns_rdata_sig_t *sig = (dns_rdata_sig_t *) source;
- REQUIRE(source != NULL);
+ REQUIRE(sig != NULL);
REQUIRE(sig->common.rdtype == dns_rdatatype_sig);
if (sig->mctx == NULL)
dns_rdata_sink_t *sink = source;
REQUIRE(type == dns_rdatatype_sink);
- REQUIRE(source != NULL);
+ REQUIRE(sink != NULL);
REQUIRE(sink->common.rdtype == type);
REQUIRE(sink->common.rdclass == rdclass);
isc_region_t sr;
REQUIRE(rdata->type == dns_rdatatype_sink);
- REQUIRE(target != NULL);
+ REQUIRE(sink != NULL);
REQUIRE(rdata->length >= 3);
sink->common.rdclass = rdata->rdclass;
freestruct_sink(ARGS_FREESTRUCT) {
dns_rdata_sink_t *sink = (dns_rdata_sink_t *) source;
- REQUIRE(source != NULL);
+ REQUIRE(sink != NULL);
REQUIRE(sink->common.rdtype == dns_rdatatype_sink);
if (sink->mctx == NULL)
tostruct_smimea(ARGS_TOSTRUCT) {
dns_rdata_smimea_t *smimea = target;
+ REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_smimea);
- REQUIRE(target != NULL);
+ REQUIRE(smimea != NULL);
smimea->common.rdclass = rdata->rdclass;
smimea->common.rdtype = rdata->type;
freestruct_smimea(ARGS_FREESTRUCT) {
dns_rdata_smimea_t *smimea = source;
- REQUIRE(source != NULL);
+ REQUIRE(smimea != NULL);
REQUIRE(smimea->common.rdtype == dns_rdatatype_smimea);
generic_freestruct_tlsa(source);
isc_region_t region;
REQUIRE(type == dns_rdatatype_soa);
- REQUIRE(source != NULL);
+ REQUIRE(soa != NULL);
REQUIRE(soa->common.rdtype == type);
REQUIRE(soa->common.rdclass == rdclass);
isc_result_t result;
REQUIRE(rdata->type == dns_rdatatype_soa);
- REQUIRE(target != NULL);
+ REQUIRE(soa != NULL);
REQUIRE(rdata->length != 0);
soa->common.rdclass = rdata->rdclass;
freestruct_soa(ARGS_FREESTRUCT) {
dns_rdata_soa_t *soa = source;
- REQUIRE(source != NULL);
+ REQUIRE(soa != NULL);
REQUIRE(soa->common.rdtype == dns_rdatatype_soa);
if (soa->mctx == NULL)
tostruct_spf(ARGS_TOSTRUCT) {
dns_rdata_spf_t *spf = target;
+ REQUIRE(spf != NULL);
+ REQUIRE(rdata != NULL);
REQUIRE(rdata->type == dns_rdatatype_spf);
- REQUIRE(target != NULL);
spf->common.rdclass = rdata->rdclass;
spf->common.rdtype = rdata->type;
static inline void
freestruct_spf(ARGS_FREESTRUCT) {
- dns_rdata_spf_t *txt = source;
+ dns_rdata_spf_t *spf = source;
- REQUIRE(source != NULL);
- REQUIRE(txt->common.rdtype == dns_rdatatype_spf);
+ REQUIRE(spf != NULL);
+ REQUIRE(spf->common.rdtype == dns_rdatatype_spf);
generic_freestruct_txt(source);
}
dns_rdata_sshfp_t *sshfp = source;
REQUIRE(type == dns_rdatatype_sshfp);
- REQUIRE(source != NULL);
+ REQUIRE(sshfp != NULL);
REQUIRE(sshfp->common.rdtype == type);
REQUIRE(sshfp->common.rdclass == rdclass);
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_sshfp);
- REQUIRE(target != NULL);
+ REQUIRE(sshfp != NULL);
REQUIRE(rdata->length != 0);
sshfp->common.rdclass = rdata->rdclass;
dns_rdata_ds_t *ds = target;
REQUIRE(rdata->type == dns_rdatatype_ta);
+ REQUIRE(ds != NULL);
/*
* Checked by generic_tostruct_ds().
isc_region_t region;
REQUIRE(type == dns_rdatatype_talink);
- REQUIRE(source != NULL);
+ REQUIRE(talink != NULL);
REQUIRE(talink->common.rdtype == type);
REQUIRE(talink->common.rdclass == rdclass);
isc_result_t result;
REQUIRE(rdata->type == dns_rdatatype_talink);
- REQUIRE(target != NULL);
+ REQUIRE(talink != NULL);
REQUIRE(rdata->length != 0);
talink->common.rdclass = rdata->rdclass;
freestruct_talink(ARGS_FREESTRUCT) {
dns_rdata_talink_t *talink = source;
- REQUIRE(source != NULL);
+ REQUIRE(talink != NULL);
REQUIRE(talink->common.rdtype == dns_rdatatype_talink);
if (talink->mctx == NULL)
dns_rdata_tkey_t *tkey = source;
REQUIRE(type == dns_rdatatype_tkey);
- REQUIRE(source != NULL);
+ REQUIRE(tkey != NULL);
REQUIRE(tkey->common.rdtype == type);
REQUIRE(tkey->common.rdclass == rdclass);
isc_region_t sr;
REQUIRE(rdata->type == dns_rdatatype_tkey);
- REQUIRE(target != NULL);
+ REQUIRE(tkey != NULL);
REQUIRE(rdata->length != 0);
tkey->common.rdclass = rdata->rdclass;
freestruct_tkey(ARGS_FREESTRUCT) {
dns_rdata_tkey_t *tkey = (dns_rdata_tkey_t *) source;
- REQUIRE(source != NULL);
+ REQUIRE(tkey != NULL);
if (tkey->mctx == NULL)
return;
generic_fromstruct_tlsa(ARGS_FROMSTRUCT) {
dns_rdata_tlsa_t *tlsa = source;
- REQUIRE(source != NULL);
+ REQUIRE(tlsa != NULL);
REQUIRE(tlsa->common.rdtype == type);
REQUIRE(tlsa->common.rdclass == rdclass);
dns_rdata_tlsa_t *tlsa = target;
isc_region_t region;
- REQUIRE(rdata != NULL);
+ REQUIRE(tlsa != NULL);
REQUIRE(rdata->length != 0);
REQUIRE(tlsa != NULL);
dns_rdata_tlsa_t *tlsa = target;
REQUIRE(rdata->type == dns_rdatatype_tlsa);
- REQUIRE(target != NULL);
+ REQUIRE(tlsa != NULL);
tlsa->common.rdclass = rdata->rdclass;
tlsa->common.rdtype = rdata->type;
freestruct_tlsa(ARGS_FREESTRUCT) {
dns_rdata_tlsa_t *tlsa = source;
- REQUIRE(source != NULL);
+ REQUIRE(tlsa != NULL);
REQUIRE(tlsa->common.rdtype == dns_rdatatype_tlsa);
generic_freestruct_tlsa(source);
isc_region_t region;
uint8_t length;
- REQUIRE(source != NULL);
+ REQUIRE(txt != NULL);
REQUIRE(txt->common.rdtype == type);
REQUIRE(txt->common.rdclass == rdclass);
REQUIRE(txt->txt != NULL && txt->txt_len != 0);
dns_rdata_txt_t *txt = target;
isc_region_t r;
- REQUIRE(target != NULL);
+ REQUIRE(txt != NULL);
REQUIRE(txt->common.rdclass == rdata->rdclass);
REQUIRE(txt->common.rdtype == rdata->type);
REQUIRE(!ISC_LINK_LINKED(&txt->common, link));
generic_freestruct_txt(ARGS_FREESTRUCT) {
dns_rdata_txt_t *txt = source;
- REQUIRE(source != NULL);
+ REQUIRE(txt != NULL);
if (txt->mctx == NULL)
return;
dns_rdata_txt_t *txt = target;
REQUIRE(rdata->type == dns_rdatatype_txt);
- REQUIRE(target != NULL);
+ REQUIRE(txt != NULL);
txt->common.rdclass = rdata->rdclass;
txt->common.rdtype = rdata->type;
freestruct_txt(ARGS_FREESTRUCT) {
dns_rdata_txt_t *txt = source;
- REQUIRE(source != NULL);
+ REQUIRE(txt != NULL);
REQUIRE(txt->common.rdtype == dns_rdatatype_txt);
generic_freestruct_txt(source);
dns_rdata_uri_t *uri = source;
REQUIRE(type == dns_rdatatype_uri);
- REQUIRE(source != NULL);
+ REQUIRE(uri != NULL);
REQUIRE(uri->common.rdtype == type);
REQUIRE(uri->common.rdclass == rdclass);
REQUIRE(uri->target != NULL && uri->tgt_len != 0);
isc_region_t sr;
REQUIRE(rdata->type == dns_rdatatype_uri);
- REQUIRE(target != NULL);
+ REQUIRE(uri != NULL);
REQUIRE(rdata->length != 0);
uri->common.rdclass = rdata->rdclass;
freestruct_uri(ARGS_FREESTRUCT) {
dns_rdata_uri_t *uri = (dns_rdata_uri_t *) source;
- REQUIRE(source != NULL);
+ REQUIRE(uri != NULL);
REQUIRE(uri->common.rdtype == dns_rdatatype_uri);
if (uri->mctx == NULL)
uint8_t i;
REQUIRE(type == dns_rdatatype_x25);
- REQUIRE(source != NULL);
+ REQUIRE(x25 != NULL);
REQUIRE(x25->common.rdtype == type);
REQUIRE(x25->common.rdclass == rdclass);
REQUIRE(x25->x25 != NULL && x25->x25_len != 0);
isc_region_t r;
REQUIRE(rdata->type == dns_rdatatype_x25);
- REQUIRE(target != NULL);
+ REQUIRE(x25 != NULL);
REQUIRE(rdata->length != 0);
x25->common.rdclass = rdata->rdclass;
static inline void
freestruct_x25(ARGS_FREESTRUCT) {
dns_rdata_x25_t *x25 = source;
- REQUIRE(source != NULL);
+
+ REQUIRE(x25 != NULL);
REQUIRE(x25->common.rdtype == dns_rdatatype_x25);
if (x25->mctx == NULL)
fromstruct_zonemd(ARGS_FROMSTRUCT) {
dns_rdata_zonemd_t *zonemd = source;
- REQUIRE(source != NULL);
+ REQUIRE(zonemd != NULL);
REQUIRE(zonemd->common.rdtype == type);
REQUIRE(zonemd->common.rdclass == rdclass);
isc_region_t region;
REQUIRE(rdata->type == dns_rdatatype_zonemd);
- REQUIRE(target != NULL);
+ REQUIRE(zonemd != NULL);
REQUIRE(rdata->length != 0);
zonemd->common.rdclass = rdata->rdclass;
REQUIRE(type == dns_rdatatype_a);
REQUIRE(rdclass == dns_rdataclass_hs);
- REQUIRE(source != NULL);
+ REQUIRE(a != NULL);
REQUIRE(a->common.rdtype == type);
REQUIRE(a->common.rdclass == rdclass);
REQUIRE(rdata->type == dns_rdatatype_a);
REQUIRE(rdata->rdclass == dns_rdataclass_hs);
REQUIRE(rdata->length == 4);
+ REQUIRE(a != NULL);
UNUSED(mctx);
REQUIRE(type == dns_rdatatype_a6);
REQUIRE(rdclass == dns_rdataclass_in);
- REQUIRE(source != NULL);
+ REQUIRE(a6 != NULL);
REQUIRE(a6->common.rdtype == type);
REQUIRE(a6->common.rdclass == rdclass);
REQUIRE(rdata->type == dns_rdatatype_a6);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
- REQUIRE(target != NULL);
+ REQUIRE(a6 != NULL);
REQUIRE(rdata->length != 0);
a6->common.rdclass = rdata->rdclass;
freestruct_in_a6(ARGS_FREESTRUCT) {
dns_rdata_in_a6_t *a6 = source;
- REQUIRE(source != NULL);
+ REQUIRE(a6 != NULL);
REQUIRE(a6->common.rdclass == dns_rdataclass_in);
REQUIRE(a6->common.rdtype == dns_rdatatype_a6);
REQUIRE(type == dns_rdatatype_a);
REQUIRE(rdclass == dns_rdataclass_in);
- REQUIRE(source != NULL);
+ REQUIRE(a != NULL);
REQUIRE(a->common.rdtype == type);
REQUIRE(a->common.rdclass == rdclass);
uint32_t n;
isc_region_t region;
+ REQUIRE(a != NULL);
REQUIRE(rdata->type == dns_rdatatype_a);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length == 4);
freestruct_in_a(ARGS_FREESTRUCT) {
dns_rdata_in_a_t *a = source;
- REQUIRE(source != NULL);
+ REQUIRE(a != NULL);
REQUIRE(a->common.rdtype == dns_rdatatype_a);
REQUIRE(a->common.rdclass == dns_rdataclass_in);
REQUIRE(type == dns_rdatatype_aaaa);
REQUIRE(rdclass == dns_rdataclass_in);
- REQUIRE(source != NULL);
+ REQUIRE(aaaa != NULL);
REQUIRE(aaaa->common.rdtype == type);
REQUIRE(aaaa->common.rdclass == rdclass);
REQUIRE(rdata->type == dns_rdatatype_aaaa);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
- REQUIRE(target != NULL);
+ REQUIRE(aaaa != NULL);
REQUIRE(rdata->length == 16);
UNUSED(mctx);
freestruct_in_aaaa(ARGS_FREESTRUCT) {
dns_rdata_in_aaaa_t *aaaa = source;
- REQUIRE(source != NULL);
+ REQUIRE(aaaa != NULL);
REQUIRE(aaaa->common.rdclass == dns_rdataclass_in);
REQUIRE(aaaa->common.rdtype == dns_rdatatype_aaaa);
REQUIRE(type == dns_rdatatype_apl);
REQUIRE(rdclass == dns_rdataclass_in);
- REQUIRE(source != NULL);
+ REQUIRE(apl != NULL);
REQUIRE(apl->common.rdtype == type);
REQUIRE(apl->common.rdclass == rdclass);
REQUIRE(apl->apl != NULL || apl->apl_len == 0);
dns_rdata_in_apl_t *apl = target;
isc_region_t r;
+ REQUIRE(apl != NULL);
REQUIRE(rdata->type == dns_rdatatype_apl);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
freestruct_in_apl(ARGS_FREESTRUCT) {
dns_rdata_in_apl_t *apl = source;
- REQUIRE(source != NULL);
+ REQUIRE(apl != NULL);
REQUIRE(apl->common.rdtype == dns_rdatatype_apl);
REQUIRE(apl->common.rdclass == dns_rdataclass_in);
REQUIRE(type == dns_rdatatype_atma);
REQUIRE(rdclass == dns_rdataclass_in);
- REQUIRE(source != NULL);
+ REQUIRE(atma != NULL);
REQUIRE(atma->common.rdtype == type);
REQUIRE(atma->common.rdclass == rdclass);
REQUIRE(atma->atma != NULL || atma->atma_len == 0);
REQUIRE(rdata->type == dns_rdatatype_atma);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
- REQUIRE(target != NULL);
+ REQUIRE(atma != NULL);
REQUIRE(rdata->length != 0);
atma->common.rdclass = rdata->rdclass;
freestruct_in_atma(ARGS_FREESTRUCT) {
dns_rdata_in_atma_t *atma = source;
- REQUIRE(source != NULL);
+ REQUIRE(atma != NULL);
REQUIRE(atma->common.rdclass == dns_rdataclass_in);
REQUIRE(atma->common.rdtype == dns_rdatatype_atma);
REQUIRE(type == dns_rdatatype_dhcid);
REQUIRE(rdclass == dns_rdataclass_in);
- REQUIRE(source != NULL);
+ REQUIRE(dhcid != NULL);
REQUIRE(dhcid->common.rdtype == type);
REQUIRE(dhcid->common.rdclass == rdclass);
REQUIRE(dhcid->length != 0);
REQUIRE(rdata->type == dns_rdatatype_dhcid);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
- REQUIRE(target != NULL);
+ REQUIRE(dhcid != NULL);
REQUIRE(rdata->length != 0);
dhcid->common.rdclass = rdata->rdclass;
REQUIRE(type == dns_rdatatype_eid);
REQUIRE(rdclass == dns_rdataclass_in);
- REQUIRE(source != NULL);
+ REQUIRE(eid != NULL);
REQUIRE(eid->common.rdtype == type);
REQUIRE(eid->common.rdclass == rdclass);
REQUIRE(eid->eid != NULL || eid->eid_len == 0);
REQUIRE(rdata->type == dns_rdatatype_eid);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
- REQUIRE(target != NULL);
+ REQUIRE(eid != NULL);
REQUIRE(rdata->length != 0);
eid->common.rdclass = rdata->rdclass;
freestruct_in_eid(ARGS_FREESTRUCT) {
dns_rdata_in_eid_t *eid = source;
- REQUIRE(source != NULL);
+ REQUIRE(eid != NULL);
REQUIRE(eid->common.rdclass == dns_rdataclass_in);
REQUIRE(eid->common.rdtype == dns_rdatatype_eid);
REQUIRE(type == dns_rdatatype_kx);
REQUIRE(rdclass == dns_rdataclass_in);
- REQUIRE(source != NULL);
+ REQUIRE(kx != NULL);
REQUIRE(kx->common.rdtype == type);
REQUIRE(kx->common.rdclass == rdclass);
REQUIRE(rdata->type == dns_rdatatype_kx);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
- REQUIRE(target != NULL);
+ REQUIRE(kx != NULL);
REQUIRE(rdata->length != 0);
kx->common.rdclass = rdata->rdclass;
freestruct_in_kx(ARGS_FREESTRUCT) {
dns_rdata_in_kx_t *kx = source;
- REQUIRE(source != NULL);
+ REQUIRE(kx != NULL);
REQUIRE(kx->common.rdclass == dns_rdataclass_in);
REQUIRE(kx->common.rdtype == dns_rdatatype_kx);
REQUIRE(type == dns_rdatatype_nimloc);
REQUIRE(rdclass == dns_rdataclass_in);
- REQUIRE(source != NULL);
+ REQUIRE(nimloc != NULL);
REQUIRE(nimloc->common.rdtype == type);
REQUIRE(nimloc->common.rdclass == rdclass);
REQUIRE(nimloc->nimloc != NULL || nimloc->nimloc_len == 0);
REQUIRE(rdata->type == dns_rdatatype_nimloc);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
- REQUIRE(target != NULL);
+ REQUIRE(nimloc != NULL);
REQUIRE(rdata->length != 0);
nimloc->common.rdclass = rdata->rdclass;
freestruct_in_nimloc(ARGS_FREESTRUCT) {
dns_rdata_in_nimloc_t *nimloc = source;
- REQUIRE(source != NULL);
+ REQUIRE(nimloc != NULL);
REQUIRE(nimloc->common.rdclass == dns_rdataclass_in);
REQUIRE(nimloc->common.rdtype == dns_rdatatype_nimloc);
REQUIRE(type == dns_rdatatype_nsap_ptr);
REQUIRE(rdclass == dns_rdataclass_in);
- REQUIRE(source != NULL);
+ REQUIRE(nsap_ptr != NULL);
REQUIRE(nsap_ptr->common.rdtype == type);
REQUIRE(nsap_ptr->common.rdclass == rdclass);
REQUIRE(rdata->type == dns_rdatatype_nsap_ptr);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
- REQUIRE(target != NULL);
+ REQUIRE(nsap_ptr != NULL);
REQUIRE(rdata->length != 0);
nsap_ptr->common.rdclass = rdata->rdclass;
freestruct_in_nsap_ptr(ARGS_FREESTRUCT) {
dns_rdata_in_nsap_ptr_t *nsap_ptr = source;
- REQUIRE(source != NULL);
+ REQUIRE(nsap_ptr != NULL);
REQUIRE(nsap_ptr->common.rdclass == dns_rdataclass_in);
REQUIRE(nsap_ptr->common.rdtype == dns_rdatatype_nsap_ptr);
REQUIRE(type == dns_rdatatype_nsap);
REQUIRE(rdclass == dns_rdataclass_in);
- REQUIRE(source != NULL);
+ REQUIRE(nsap != NULL);
REQUIRE(nsap->common.rdtype == type);
REQUIRE(nsap->common.rdclass == rdclass);
REQUIRE(nsap->nsap != NULL || nsap->nsap_len == 0);
REQUIRE(rdata->type == dns_rdatatype_nsap);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
- REQUIRE(target != NULL);
+ REQUIRE(nsap != NULL);
REQUIRE(rdata->length != 0);
nsap->common.rdclass = rdata->rdclass;
freestruct_in_nsap(ARGS_FREESTRUCT) {
dns_rdata_in_nsap_t *nsap = source;
- REQUIRE(source != NULL);
+ REQUIRE(nsap != NULL);
REQUIRE(nsap->common.rdclass == dns_rdataclass_in);
REQUIRE(nsap->common.rdtype == dns_rdatatype_nsap);
REQUIRE(type == dns_rdatatype_px);
REQUIRE(rdclass == dns_rdataclass_in);
- REQUIRE(source != NULL);
+ REQUIRE(px != NULL);
REQUIRE(px->common.rdtype == type);
REQUIRE(px->common.rdclass == rdclass);
REQUIRE(rdata->type == dns_rdatatype_px);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
- REQUIRE(target != NULL);
+ REQUIRE(px != NULL);
REQUIRE(rdata->length != 0);
px->common.rdclass = rdata->rdclass;
freestruct_in_px(ARGS_FREESTRUCT) {
dns_rdata_in_px_t *px = source;
- REQUIRE(source != NULL);
+ REQUIRE(px != NULL);
REQUIRE(px->common.rdclass == dns_rdataclass_in);
REQUIRE(px->common.rdtype == dns_rdatatype_px);
REQUIRE(type == dns_rdatatype_srv);
REQUIRE(rdclass == dns_rdataclass_in);
- REQUIRE(source != NULL);
+ REQUIRE(srv != NULL);
REQUIRE(srv->common.rdtype == type);
REQUIRE(srv->common.rdclass == rdclass);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->type == dns_rdatatype_srv);
- REQUIRE(target != NULL);
+ REQUIRE(srv != NULL);
REQUIRE(rdata->length != 0);
srv->common.rdclass = rdata->rdclass;
freestruct_in_srv(ARGS_FREESTRUCT) {
dns_rdata_in_srv_t *srv = source;
- REQUIRE(source != NULL);
+ REQUIRE(srv != NULL);
REQUIRE(srv->common.rdclass == dns_rdataclass_in);
REQUIRE(srv->common.rdtype == dns_rdatatype_srv);
REQUIRE(type == dns_rdatatype_wks);
REQUIRE(rdclass == dns_rdataclass_in);
- REQUIRE(source != NULL);
+ REQUIRE(wks != NULL);
REQUIRE(wks->common.rdtype == type);
REQUIRE(wks->common.rdclass == rdclass);
REQUIRE((wks->map != NULL && wks->map_len <= 8*1024) ||
uint32_t n;
isc_region_t region;
+ REQUIRE(wks != NULL);
REQUIRE(rdata->type == dns_rdatatype_wks);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length != 0);
freestruct_in_wks(ARGS_FREESTRUCT) {
dns_rdata_in_wks_t *wks = source;
- REQUIRE(source != NULL);
+ REQUIRE(wks != NULL);
REQUIRE(wks->common.rdtype == dns_rdatatype_wks);
REQUIRE(wks->common.rdclass == dns_rdataclass_in);