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);
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;
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);
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;
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);
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;
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);
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);
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;
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);
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);
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;
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;
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);
}
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);
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);
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;
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);
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);
}
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().
*/
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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;
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;
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);
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);
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;
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);
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);
}
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));
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);
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;
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);
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);
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;
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;
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);
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;
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;
}
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);
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;
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;
}
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
}
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);
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;
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;
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);
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;
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;
}
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);
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;
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;
}
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);
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);
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);
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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;
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;
}
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;
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);
}
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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;
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;
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);
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);
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;
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);
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);
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;
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);
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;
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;
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);
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);
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;
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);
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);
}
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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;
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);
}
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);
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);
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;
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);
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);
}
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);
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);
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;
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().
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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;
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);
}
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);
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;
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;
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;
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);
}
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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;
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);
}
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);
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;
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);
}
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
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);
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);
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;
projects / thirdparty / bind9.git / commitdiff
