+4182. [cleanup] Use mnemonics for RR class and type comparisons.
+ [RT #40297]
+
4181. [bug] Queued notify messages could be dequeued from the
wrong rate limiter queue. [RT #40350]
long i;
char *e;
- REQUIRE(type == 250);
- REQUIRE(rdclass == 255);
+ REQUIRE(type == dns_rdatatype_tsig);
+ REQUIRE(rdclass == dns_rdataclass_any);
UNUSED(type);
UNUSED(rdclass);
isc_uint64_t sigtime;
unsigned short n;
- REQUIRE(rdata->type == 250);
- REQUIRE(rdata->rdclass == 255);
+ REQUIRE(rdata->type == dns_rdatatype_tsig);
+ REQUIRE(rdata->rdclass == dns_rdataclass_any);
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, &sr);
dns_name_t name;
unsigned long n;
- REQUIRE(type == 250);
- REQUIRE(rdclass == 255);
+ REQUIRE(type == dns_rdatatype_tsig);
+ REQUIRE(rdclass == dns_rdataclass_any);
UNUSED(type);
UNUSED(rdclass);
dns_name_t name;
dns_offsets_t offsets;
- REQUIRE(rdata->type == 250);
- REQUIRE(rdata->rdclass == 255);
+ REQUIRE(rdata->type == dns_rdatatype_tsig);
+ REQUIRE(rdata->rdclass == dns_rdataclass_any);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_NONE);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 250);
- REQUIRE(rdata1->rdclass == 255);
+ REQUIRE(rdata1->type == dns_rdatatype_tsig);
+ REQUIRE(rdata1->rdclass == dns_rdataclass_any);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_any_tsig_t *tsig = source;
isc_region_t tr;
- REQUIRE(type == 250);
- REQUIRE(rdclass == 255);
+ REQUIRE(type == dns_rdatatype_tsig);
+ REQUIRE(rdclass == dns_rdataclass_any);
REQUIRE(source != NULL);
REQUIRE(tsig->common.rdclass == rdclass);
REQUIRE(tsig->common.rdtype == type);
dns_name_t alg;
isc_region_t sr;
- REQUIRE(rdata->type == 250);
- REQUIRE(rdata->rdclass == 255);
+ REQUIRE(rdata->type == dns_rdatatype_tsig);
+ REQUIRE(rdata->rdclass == dns_rdataclass_any);
REQUIRE(rdata->length != 0);
tsig = (dns_rdata_any_tsig_t *) target;
dns_rdata_any_tsig_t *tsig = (dns_rdata_any_tsig_t *) source;
REQUIRE(source != NULL);
- REQUIRE(tsig->common.rdtype == 250);
- REQUIRE(tsig->common.rdclass == 255);
+ REQUIRE(tsig->common.rdtype == dns_rdatatype_tsig);
+ REQUIRE(tsig->common.rdclass == dns_rdataclass_any);
if (tsig->mctx == NULL)
return;
static inline isc_result_t
additionaldata_any_tsig(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 250);
- REQUIRE(rdata->rdclass == 255);
+ REQUIRE(rdata->type == dns_rdatatype_tsig);
+ REQUIRE(rdata->rdclass == dns_rdataclass_any);
UNUSED(rdata);
UNUSED(add);
static inline isc_result_t
digest_any_tsig(ARGS_DIGEST) {
- REQUIRE(rdata->type == 250);
- REQUIRE(rdata->rdclass == 255);
+ REQUIRE(rdata->type == dns_rdatatype_tsig);
+ REQUIRE(rdata->rdclass == dns_rdataclass_any);
UNUSED(rdata);
UNUSED(digest);
static inline isc_boolean_t
checkowner_any_tsig(ARGS_CHECKOWNER) {
- REQUIRE(type == 250);
- REQUIRE(rdclass == 255);
+ REQUIRE(type == dns_rdatatype_tsig);
+ REQUIRE(rdclass == dns_rdataclass_any);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_any_tsig(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 250);
- REQUIRE(rdata->rdclass == 255);
+ REQUIRE(rdata->type == dns_rdatatype_tsig);
+ REQUIRE(rdata->rdclass == dns_rdataclass_any);
UNUSED(rdata);
UNUSED(owner);
dns_name_t name;
isc_buffer_t buffer;
- REQUIRE(type == 1);
+ REQUIRE(type == dns_rdatatype_a);
REQUIRE(rdclass == dns_rdataclass_ch); /* 3 */
UNUSED(type);
char buf[sizeof("0177777")];
isc_uint16_t addr;
- REQUIRE(rdata->type == 1);
+ REQUIRE(rdata->type == dns_rdatatype_a);
REQUIRE(rdata->rdclass == dns_rdataclass_ch); /* 3 */
REQUIRE(rdata->length != 0);
isc_region_t tregion;
dns_name_t name;
- REQUIRE(type == 1);
+ REQUIRE(type == dns_rdatatype_a);
REQUIRE(rdclass == dns_rdataclass_ch);
UNUSED(type);
isc_region_t sregion;
isc_region_t tregion;
- REQUIRE(rdata->type == 1);
+ REQUIRE(rdata->type == dns_rdatatype_a);
REQUIRE(rdata->rdclass == dns_rdataclass_ch);
REQUIRE(rdata->length != 0);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 1);
+ REQUIRE(rdata1->type == dns_rdatatype_a);
REQUIRE(rdata1->rdclass == dns_rdataclass_ch);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_ch_a_t *a = source;
isc_region_t region;
- REQUIRE(type == 1);
+ REQUIRE(type == dns_rdatatype_a);
REQUIRE(source != NULL);
REQUIRE(a->common.rdtype == type);
REQUIRE(a->common.rdclass == rdclass);
isc_region_t region;
dns_name_t name;
- REQUIRE(rdata->type == 1);
+ REQUIRE(rdata->type == dns_rdatatype_a);
REQUIRE(rdata->rdclass == dns_rdataclass_ch);
REQUIRE(rdata->length != 0);
dns_rdata_ch_a_t *a = source;
REQUIRE(source != NULL);
- REQUIRE(a->common.rdtype == 1);
+ REQUIRE(a->common.rdtype == dns_rdatatype_a);
if (a->mctx == NULL)
return;
static inline isc_result_t
additionaldata_ch_a(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 1);
+ REQUIRE(rdata->type == dns_rdatatype_a);
REQUIRE(rdata->rdclass == dns_rdataclass_ch);
UNUSED(rdata);
static inline isc_result_t
digest_ch_a(ARGS_DIGEST) {
isc_region_t r;
-
dns_name_t name;
- REQUIRE(rdata->type == 1);
+ REQUIRE(rdata->type == dns_rdatatype_a);
REQUIRE(rdata->rdclass == dns_rdataclass_ch);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_ch_a(ARGS_CHECKOWNER) {
- REQUIRE(type == 1);
+ REQUIRE(type == dns_rdatatype_a);
REQUIRE(rdclass == dns_rdataclass_ch);
UNUSED(type);
isc_region_t region;
dns_name_t name;
- REQUIRE(rdata->type == 1);
+ REQUIRE(rdata->type == dns_rdatatype_a);
REQUIRE(rdata->rdclass == dns_rdataclass_ch);
UNUSED(owner);
dns_name_t name;
isc_boolean_t ok;
- REQUIRE(type == 18);
+ REQUIRE(type == dns_rdatatype_afsdb);
UNUSED(type);
UNUSED(rdclass);
isc_boolean_t sub;
unsigned int num;
- REQUIRE(rdata->type == 18);
+ REQUIRE(rdata->type == dns_rdatatype_afsdb);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
isc_region_t sr;
isc_region_t tr;
- REQUIRE(type == 18);
+ REQUIRE(type == dns_rdatatype_afsdb);
UNUSED(type);
UNUSED(rdclass);
dns_name_t name;
dns_offsets_t offsets;
- REQUIRE(rdata->type == 18);
+ REQUIRE(rdata->type == dns_rdatatype_afsdb);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_NONE);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 18);
+ REQUIRE(rdata1->type == dns_rdatatype_afsdb);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_afsdb_t *afsdb = source;
isc_region_t region;
- REQUIRE(type == 18);
+ REQUIRE(type == dns_rdatatype_afsdb);
REQUIRE(source != NULL);
REQUIRE(afsdb->common.rdclass == rdclass);
REQUIRE(afsdb->common.rdtype == type);
dns_rdata_afsdb_t *afsdb = target;
dns_name_t name;
- REQUIRE(rdata->type == 18);
+ REQUIRE(rdata->type == dns_rdatatype_afsdb);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_afsdb_t *afsdb = source;
REQUIRE(source != NULL);
- REQUIRE(afsdb->common.rdtype == 18);
+ REQUIRE(afsdb->common.rdtype == dns_rdatatype_afsdb);
if (afsdb->mctx == NULL)
return;
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 18);
+ REQUIRE(rdata->type == dns_rdatatype_afsdb);
dns_name_init(&name, offsets);
dns_rdata_toregion(rdata, ®ion);
isc_region_t r1, r2;
dns_name_t name;
- REQUIRE(rdata->type == 18);
+ REQUIRE(rdata->type == dns_rdatatype_afsdb);
dns_rdata_toregion(rdata, &r1);
r2 = r1;
static inline isc_boolean_t
checkowner_afsdb(ARGS_CHECKOWNER) {
- REQUIRE(type == 18);
+ REQUIRE(type == dns_rdatatype_afsdb);
UNUSED(name);
UNUSED(type);
isc_region_t region;
dns_name_t name;
- REQUIRE(rdata->type == 18);
+ REQUIRE(rdata->type == dns_rdatatype_afsdb);
UNUSED(owner);
isc_uint8_t flags;
unsigned int i;
- REQUIRE(type == 257);
+ REQUIRE(type == dns_rdatatype_caa);
UNUSED(type);
UNUSED(rdclass);
UNUSED(tctx);
- REQUIRE(rdata->type == 257);
+ REQUIRE(rdata->type == dns_rdatatype_caa);
REQUIRE(rdata->length >= 3U);
REQUIRE(rdata->data != NULL);
isc_region_t sr;
unsigned int len, i;
- REQUIRE(type == 257);
+ REQUIRE(type == dns_rdatatype_caa);
UNUSED(type);
UNUSED(rdclass);
towire_caa(ARGS_TOWIRE) {
isc_region_t region;
- REQUIRE(rdata->type == 257);
+ REQUIRE(rdata->type == dns_rdatatype_caa);
REQUIRE(rdata->length >= 3U);
REQUIRE(rdata->data != NULL);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 257);
+ REQUIRE(rdata1->type == dns_rdatatype_caa);
REQUIRE(rdata1->length >= 3U);
REQUIRE(rdata2->length >= 3U);
REQUIRE(rdata1->data != NULL);
isc_region_t region;
unsigned int i;
- REQUIRE(type == 257);
+ REQUIRE(type == dns_rdatatype_caa);
REQUIRE(source != NULL);
REQUIRE(caa->common.rdtype == type);
REQUIRE(caa->common.rdclass == rdclass);
dns_rdata_caa_t *caa = target;
isc_region_t sr;
- REQUIRE(rdata->type == 257);
+ REQUIRE(rdata->type == dns_rdatatype_caa);
REQUIRE(target != NULL);
REQUIRE(rdata->length >= 3U);
REQUIRE(rdata->data != NULL);
dns_rdata_caa_t *caa = (dns_rdata_caa_t *) source;
REQUIRE(source != NULL);
- REQUIRE(caa->common.rdtype == 257);
+ REQUIRE(caa->common.rdtype == dns_rdatatype_caa);
if (caa->mctx == NULL)
return;
static inline isc_result_t
additionaldata_caa(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 257);
+ REQUIRE(rdata->type == dns_rdatatype_caa);
REQUIRE(rdata->data != NULL);
REQUIRE(rdata->length >= 3U);
digest_caa(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 257);
+ REQUIRE(rdata->type == dns_rdatatype_caa);
REQUIRE(rdata->data != NULL);
REQUIRE(rdata->length >= 3U);
static inline isc_boolean_t
checkowner_caa(ARGS_CHECKOWNER) {
- REQUIRE(type == 257);
+ REQUIRE(type == dns_rdatatype_caa);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_caa(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 257);
+ REQUIRE(rdata->type == dns_rdatatype_caa);
REQUIRE(rdata->data != NULL);
REQUIRE(rdata->length >= 3U);
dns_secproto_t proto;
dns_keyflags_t flags;
- REQUIRE(type == 60);
+ REQUIRE(type == dns_rdatatype_cdnskey);
UNUSED(type);
UNUSED(rdclass);
char algbuf[DNS_NAME_FORMATSIZE];
const char *keyinfo;
- REQUIRE(rdata->type == 60);
+ REQUIRE(rdata->type == dns_rdatatype_cdnskey);
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, &sr);
unsigned char algorithm;
isc_region_t sr;
- REQUIRE(type == 60);
+ REQUIRE(type == dns_rdatatype_cdnskey);
UNUSED(type);
UNUSED(rdclass);
towire_cdnskey(ARGS_TOWIRE) {
isc_region_t sr;
- REQUIRE(rdata->type == 60);
+ REQUIRE(rdata->type == dns_rdatatype_cdnskey);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 60);
+ REQUIRE(rdata1->type == dns_rdatatype_cdnskey);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_cdnskey(ARGS_FROMSTRUCT) {
dns_rdata_cdnskey_t *dnskey = source;
- REQUIRE(type == 60);
+ REQUIRE(type == dns_rdatatype_cdnskey);
REQUIRE(source != NULL);
REQUIRE(dnskey->common.rdtype == type);
REQUIRE(dnskey->common.rdclass == rdclass);
dns_rdata_cdnskey_t *dnskey = target;
isc_region_t sr;
- REQUIRE(rdata->type == 60);
+ REQUIRE(rdata->type == dns_rdatatype_cdnskey);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_cdnskey_t *dnskey = (dns_rdata_cdnskey_t *) source;
REQUIRE(source != NULL);
- REQUIRE(dnskey->common.rdtype == 60);
+ REQUIRE(dnskey->common.rdtype == dns_rdatatype_cdnskey);
if (dnskey->mctx == NULL)
return;
static inline isc_result_t
additionaldata_cdnskey(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 60);
+ REQUIRE(rdata->type == dns_rdatatype_cdnskey);
UNUSED(rdata);
UNUSED(add);
digest_cdnskey(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 60);
+ REQUIRE(rdata->type == dns_rdatatype_cdnskey);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_cdnskey(ARGS_CHECKOWNER) {
- REQUIRE(type == 60);
+ REQUIRE(type == dns_rdatatype_cdnskey);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_cdnskey(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 60);
+ REQUIRE(rdata->type == dns_rdatatype_cdnskey);
UNUSED(rdata);
UNUSED(owner);
unsigned char c;
int length;
- REQUIRE(type == 59);
+ REQUIRE(type == dns_rdatatype_cds);
UNUSED(type);
UNUSED(rdclass);
char buf[sizeof("64000 ")];
unsigned int n;
- REQUIRE(rdata->type == 59);
+ REQUIRE(rdata->type == dns_rdatatype_cds);
REQUIRE(rdata->length != 0);
UNUSED(tctx);
fromwire_cds(ARGS_FROMWIRE) {
isc_region_t sr;
- REQUIRE(type == 59);
+ REQUIRE(type == dns_rdatatype_cds);
UNUSED(type);
UNUSED(rdclass);
towire_cds(ARGS_TOWIRE) {
isc_region_t sr;
- REQUIRE(rdata->type == 59);
+ REQUIRE(rdata->type == dns_rdatatype_cds);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 59);
+ REQUIRE(rdata1->type == dns_rdatatype_cds);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_cds(ARGS_FROMSTRUCT) {
dns_rdata_cds_t *ds = source;
- REQUIRE(type == 59);
+ REQUIRE(type == dns_rdatatype_cds);
REQUIRE(source != NULL);
REQUIRE(ds->common.rdtype == type);
REQUIRE(ds->common.rdclass == rdclass);
dns_rdata_cds_t *ds = target;
isc_region_t region;
- REQUIRE(rdata->type == 59);
+ REQUIRE(rdata->type == dns_rdatatype_cds);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_cds_t *ds = source;
REQUIRE(ds != NULL);
- REQUIRE(ds->common.rdtype == 59);
+ REQUIRE(ds->common.rdtype == dns_rdatatype_cds);
if (ds->mctx == NULL)
return;
static inline isc_result_t
additionaldata_cds(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 59);
+ REQUIRE(rdata->type == dns_rdatatype_cds);
UNUSED(rdata);
UNUSED(add);
digest_cds(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 59);
+ REQUIRE(rdata->type == dns_rdatatype_cds);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_cds(ARGS_CHECKOWNER) {
- REQUIRE(type == 59);
+ REQUIRE(type == dns_rdatatype_cds);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_cds(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 59);
+ REQUIRE(rdata->type == dns_rdatatype_cds);
UNUSED(rdata);
UNUSED(owner);
dns_secalg_t secalg;
dns_cert_t cert;
- REQUIRE(type == 37);
+ REQUIRE(type == dns_rdatatype_cert);
UNUSED(type);
UNUSED(rdclass);
char buf[sizeof("64000 ")];
unsigned int n;
- REQUIRE(rdata->type == 37);
+ REQUIRE(rdata->type == dns_rdatatype_cert);
REQUIRE(rdata->length != 0);
UNUSED(tctx);
fromwire_cert(ARGS_FROMWIRE) {
isc_region_t sr;
- REQUIRE(type == 37);
+ REQUIRE(type == dns_rdatatype_cert);
UNUSED(type);
UNUSED(rdclass);
towire_cert(ARGS_TOWIRE) {
isc_region_t sr;
- REQUIRE(rdata->type == 37);
+ REQUIRE(rdata->type == dns_rdatatype_cert);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 37);
+ REQUIRE(rdata1->type == dns_rdatatype_cert);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_cert(ARGS_FROMSTRUCT) {
dns_rdata_cert_t *cert = source;
- REQUIRE(type == 37);
+ REQUIRE(type == dns_rdatatype_cert);
REQUIRE(source != NULL);
REQUIRE(cert->common.rdtype == type);
REQUIRE(cert->common.rdclass == rdclass);
dns_rdata_cert_t *cert = target;
isc_region_t region;
- REQUIRE(rdata->type == 37);
+ REQUIRE(rdata->type == dns_rdatatype_cert);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_cert_t *cert = source;
REQUIRE(cert != NULL);
- REQUIRE(cert->common.rdtype == 37);
+ REQUIRE(cert->common.rdtype == dns_rdatatype_cert);
if (cert->mctx == NULL)
return;
static inline isc_result_t
additionaldata_cert(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 37);
+ REQUIRE(rdata->type == dns_rdatatype_cert);
UNUSED(rdata);
UNUSED(add);
digest_cert(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 37);
+ REQUIRE(rdata->type == dns_rdatatype_cert);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_cert(ARGS_CHECKOWNER) {
- REQUIRE(type == 37);
+ REQUIRE(type == dns_rdatatype_cert);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_cert(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 37);
+ REQUIRE(rdata->type == dns_rdatatype_cert);
UNUSED(rdata);
UNUSED(owner);
dns_name_t name;
isc_buffer_t buffer;
- REQUIRE(type == 5);
+ REQUIRE(type == dns_rdatatype_cname);
UNUSED(type);
UNUSED(rdclass);
dns_name_t prefix;
isc_boolean_t sub;
- REQUIRE(rdata->type == 5);
+ REQUIRE(rdata->type == dns_rdatatype_cname);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
fromwire_cname(ARGS_FROMWIRE) {
dns_name_t name;
- REQUIRE(type == 5);
+ REQUIRE(type == dns_rdatatype_cname);
UNUSED(type);
UNUSED(rdclass);
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 5);
+ REQUIRE(rdata->type == dns_rdatatype_cname);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_GLOBAL14);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 5);
+ REQUIRE(rdata1->type == dns_rdatatype_cname);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_cname_t *cname = source;
isc_region_t region;
- REQUIRE(type == 5);
+ REQUIRE(type == dns_rdatatype_cname);
REQUIRE(source != NULL);
REQUIRE(cname->common.rdtype == type);
REQUIRE(cname->common.rdclass == rdclass);
dns_rdata_cname_t *cname = target;
dns_name_t name;
- REQUIRE(rdata->type == 5);
+ REQUIRE(rdata->type == dns_rdatatype_cname);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
UNUSED(add);
UNUSED(arg);
- REQUIRE(rdata->type == 5);
+ REQUIRE(rdata->type == dns_rdatatype_cname);
return (ISC_R_SUCCESS);
}
isc_region_t r;
dns_name_t name;
- REQUIRE(rdata->type == 5);
+ REQUIRE(rdata->type == dns_rdatatype_cname);
dns_rdata_toregion(rdata, &r);
dns_name_init(&name, NULL);
static inline isc_boolean_t
checkowner_cname(ARGS_CHECKOWNER) {
- REQUIRE(type == 5);
+ REQUIRE(type == dns_rdatatype_cname);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_cname(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 5);
+ REQUIRE(rdata->type == dns_rdatatype_cname);
UNUSED(rdata);
UNUSED(owner);
unsigned char c;
int length;
- REQUIRE(type == 32769);
+ REQUIRE(type == dns_rdatatype_dlv);
UNUSED(type);
UNUSED(rdclass);
char buf[sizeof("64000 ")];
unsigned int n;
- REQUIRE(rdata->type == 32769);
+ REQUIRE(rdata->type == dns_rdatatype_dlv);
REQUIRE(rdata->length != 0);
UNUSED(tctx);
fromwire_dlv(ARGS_FROMWIRE) {
isc_region_t sr;
- REQUIRE(type == 32769);
+ REQUIRE(type == dns_rdatatype_dlv);
UNUSED(type);
UNUSED(rdclass);
towire_dlv(ARGS_TOWIRE) {
isc_region_t sr;
- REQUIRE(rdata->type == 32769);
+ REQUIRE(rdata->type == dns_rdatatype_dlv);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 32769);
+ REQUIRE(rdata1->type == dns_rdatatype_dlv);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_dlv(ARGS_FROMSTRUCT) {
dns_rdata_dlv_t *dlv = source;
- REQUIRE(type == 32769);
+ REQUIRE(type == dns_rdatatype_dlv);
REQUIRE(source != NULL);
REQUIRE(dlv->common.rdtype == type);
REQUIRE(dlv->common.rdclass == rdclass);
dns_rdata_dlv_t *dlv = target;
isc_region_t region;
- REQUIRE(rdata->type == 32769);
+ REQUIRE(rdata->type == dns_rdatatype_dlv);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_dlv_t *dlv = source;
REQUIRE(dlv != NULL);
- REQUIRE(dlv->common.rdtype == 32769);
+ REQUIRE(dlv->common.rdtype == dns_rdatatype_dlv);
if (dlv->mctx == NULL)
return;
static inline isc_result_t
additionaldata_dlv(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 32769);
+ REQUIRE(rdata->type == dns_rdatatype_dlv);
UNUSED(rdata);
UNUSED(add);
digest_dlv(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 32769);
+ REQUIRE(rdata->type == dns_rdatatype_dlv);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_dlv(ARGS_CHECKOWNER) {
- REQUIRE(type == 32769);
+ REQUIRE(type == dns_rdatatype_dlv);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_dlv(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 32769);
+ REQUIRE(rdata->type == dns_rdatatype_dlv);
UNUSED(rdata);
UNUSED(owner);
dns_name_t name;
isc_buffer_t buffer;
- REQUIRE(type == 39);
+ REQUIRE(type == dns_rdatatype_dname);
UNUSED(type);
UNUSED(rdclass);
dns_name_t prefix;
isc_boolean_t sub;
- REQUIRE(rdata->type == 39);
+ REQUIRE(rdata->type == dns_rdatatype_dname);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
fromwire_dname(ARGS_FROMWIRE) {
dns_name_t name;
- REQUIRE(type == 39);
+ REQUIRE(type == dns_rdatatype_dname);
UNUSED(type);
UNUSED(rdclass);
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 39);
+ REQUIRE(rdata->type == dns_rdatatype_dname);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_NONE);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 39);
+ REQUIRE(rdata1->type == dns_rdatatype_dname);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_dname_t *dname = source;
isc_region_t region;
- REQUIRE(type == 39);
+ REQUIRE(type == dns_rdatatype_dname);
REQUIRE(source != NULL);
REQUIRE(dname->common.rdtype == type);
REQUIRE(dname->common.rdclass == rdclass);
dns_rdata_dname_t *dname = target;
dns_name_t name;
- REQUIRE(rdata->type == 39);
+ REQUIRE(rdata->type == dns_rdatatype_dname);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_dname_t *dname = source;
REQUIRE(source != NULL);
- REQUIRE(dname->common.rdtype == 39);
+ REQUIRE(dname->common.rdtype == dns_rdatatype_dname);
if (dname->mctx == NULL)
return;
UNUSED(add);
UNUSED(arg);
- REQUIRE(rdata->type == 39);
+ REQUIRE(rdata->type == dns_rdatatype_dname);
return (ISC_R_SUCCESS);
}
isc_region_t r;
dns_name_t name;
- REQUIRE(rdata->type == 39);
+ REQUIRE(rdata->type == dns_rdatatype_dname);
dns_rdata_toregion(rdata, &r);
dns_name_init(&name, NULL);
static inline isc_boolean_t
checkowner_dname(ARGS_CHECKOWNER) {
- REQUIRE(type == 39);
+ REQUIRE(type == dns_rdatatype_dname);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_dname(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 39);
+ REQUIRE(rdata->type == dns_rdatatype_dname);
UNUSED(rdata);
UNUSED(owner);
dns_secproto_t proto;
dns_keyflags_t flags;
- REQUIRE(type == 48);
+ REQUIRE(type == dns_rdatatype_dnskey);
UNUSED(type);
UNUSED(rdclass);
char algbuf[DNS_NAME_FORMATSIZE];
const char *keyinfo;
- REQUIRE(rdata->type == 48);
+ REQUIRE(rdata->type == dns_rdatatype_dnskey);
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, &sr);
unsigned char algorithm;
isc_region_t sr;
- REQUIRE(type == 48);
+ REQUIRE(type == dns_rdatatype_dnskey);
UNUSED(type);
UNUSED(rdclass);
towire_dnskey(ARGS_TOWIRE) {
isc_region_t sr;
- REQUIRE(rdata->type == 48);
+ REQUIRE(rdata->type == dns_rdatatype_dnskey);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 48);
+ REQUIRE(rdata1->type == dns_rdatatype_dnskey);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_dnskey(ARGS_FROMSTRUCT) {
dns_rdata_dnskey_t *dnskey = source;
- REQUIRE(type == 48);
+ REQUIRE(type == dns_rdatatype_dnskey);
REQUIRE(source != NULL);
REQUIRE(dnskey->common.rdtype == type);
REQUIRE(dnskey->common.rdclass == rdclass);
dns_rdata_dnskey_t *dnskey = target;
isc_region_t sr;
- REQUIRE(rdata->type == 48);
+ REQUIRE(rdata->type == dns_rdatatype_dnskey);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_dnskey_t *dnskey = (dns_rdata_dnskey_t *) source;
REQUIRE(source != NULL);
- REQUIRE(dnskey->common.rdtype == 48);
+ REQUIRE(dnskey->common.rdtype == dns_rdatatype_dnskey);
if (dnskey->mctx == NULL)
return;
static inline isc_result_t
additionaldata_dnskey(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 48);
+ REQUIRE(rdata->type == dns_rdatatype_dnskey);
UNUSED(rdata);
UNUSED(add);
digest_dnskey(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 48);
+ REQUIRE(rdata->type == dns_rdatatype_dnskey);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_dnskey(ARGS_CHECKOWNER) {
- REQUIRE(type == 48);
+ REQUIRE(type == dns_rdatatype_dnskey);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_dnskey(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 48);
+ REQUIRE(rdata->type == dns_rdatatype_dnskey);
UNUSED(rdata);
UNUSED(owner);
unsigned char c;
int length;
- REQUIRE(type == 43);
+ REQUIRE(type == dns_rdatatype_ds);
UNUSED(type);
UNUSED(rdclass);
char buf[sizeof("64000 ")];
unsigned int n;
- REQUIRE(rdata->type == 43);
+ REQUIRE(rdata->type == dns_rdatatype_ds);
REQUIRE(rdata->length != 0);
UNUSED(tctx);
fromwire_ds(ARGS_FROMWIRE) {
isc_region_t sr;
- REQUIRE(type == 43);
+ REQUIRE(type == dns_rdatatype_ds);
UNUSED(type);
UNUSED(rdclass);
towire_ds(ARGS_TOWIRE) {
isc_region_t sr;
- REQUIRE(rdata->type == 43);
+ REQUIRE(rdata->type == dns_rdatatype_ds);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 43);
+ REQUIRE(rdata1->type == dns_rdatatype_ds);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_ds(ARGS_FROMSTRUCT) {
dns_rdata_ds_t *ds = source;
- REQUIRE(type == 43);
+ REQUIRE(type == dns_rdatatype_ds);
REQUIRE(source != NULL);
REQUIRE(ds->common.rdtype == type);
REQUIRE(ds->common.rdclass == rdclass);
dns_rdata_ds_t *ds = target;
isc_region_t region;
- REQUIRE(rdata->type == 43);
+ REQUIRE(rdata->type == dns_rdatatype_ds);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_ds_t *ds = source;
REQUIRE(ds != NULL);
- REQUIRE(ds->common.rdtype == 43);
+ REQUIRE(ds->common.rdtype == dns_rdatatype_ds);
if (ds->mctx == NULL)
return;
static inline isc_result_t
additionaldata_ds(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 43);
+ REQUIRE(rdata->type == dns_rdatatype_ds);
UNUSED(rdata);
UNUSED(add);
digest_ds(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 43);
+ REQUIRE(rdata->type == dns_rdatatype_ds);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_ds(ARGS_CHECKOWNER) {
- REQUIRE(type == 43);
+ REQUIRE(type == dns_rdatatype_ds);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_ds(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 43);
+ REQUIRE(rdata->type == dns_rdatatype_ds);
UNUSED(rdata);
UNUSED(owner);
unsigned int l0, l1, l2, l3, l4, l5;
int n;
- REQUIRE(type == 108);
+ REQUIRE(type == dns_rdatatype_eui48);
UNUSED(type);
UNUSED(rdclass);
totext_eui48(ARGS_TOTEXT) {
char buf[sizeof("xx-xx-xx-xx-xx-xx")];
- REQUIRE(rdata->type == 108);
+ REQUIRE(rdata->type == dns_rdatatype_eui48);
REQUIRE(rdata->length == 6);
UNUSED(tctx);
fromwire_eui48(ARGS_FROMWIRE) {
isc_region_t sregion;
- REQUIRE(type == 108);
+ REQUIRE(type == dns_rdatatype_eui48);
UNUSED(type);
UNUSED(options);
static inline isc_result_t
towire_eui48(ARGS_TOWIRE) {
- REQUIRE(rdata->type == 108);
+ REQUIRE(rdata->type == dns_rdatatype_eui48);
REQUIRE(rdata->length == 6);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 108);
+ REQUIRE(rdata1->type == dns_rdatatype_eui48);
REQUIRE(rdata1->length == 6);
REQUIRE(rdata2->length == 6);
fromstruct_eui48(ARGS_FROMSTRUCT) {
dns_rdata_eui48_t *eui48 = source;
- REQUIRE(type == 108);
+ REQUIRE(type == dns_rdatatype_eui48);
REQUIRE(source != NULL);
REQUIRE(eui48->common.rdtype == type);
REQUIRE(eui48->common.rdclass == rdclass);
tostruct_eui48(ARGS_TOSTRUCT) {
dns_rdata_eui48_t *eui48 = target;
- REQUIRE(rdata->type == 108);
+ REQUIRE(rdata->type == dns_rdatatype_eui48);
REQUIRE(target != NULL);
REQUIRE(rdata->length == 6);
dns_rdata_eui48_t *eui48 = source;
REQUIRE(source != NULL);
- REQUIRE(eui48->common.rdtype == 108);
+ REQUIRE(eui48->common.rdtype == dns_rdatatype_eui48);
return;
}
static inline isc_result_t
additionaldata_eui48(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 108);
+ REQUIRE(rdata->type == dns_rdatatype_eui48);
REQUIRE(rdata->length == 6);
UNUSED(rdata);
digest_eui48(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 108);
+ REQUIRE(rdata->type == dns_rdatatype_eui48);
REQUIRE(rdata->length == 6);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_eui48(ARGS_CHECKOWNER) {
- REQUIRE(type == 108);
+ REQUIRE(type == dns_rdatatype_eui48);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_eui48(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 108);
+ REQUIRE(rdata->type == dns_rdatatype_eui48);
REQUIRE(rdata->length == 6);
UNUSED(rdata);
unsigned int l0, l1, l2, l3, l4, l5, l6, l7;
int n;
- REQUIRE(type == 109);
+ REQUIRE(type == dns_rdatatype_eui64);
UNUSED(type);
UNUSED(rdclass);
totext_eui64(ARGS_TOTEXT) {
char buf[sizeof("xx-xx-xx-xx-xx-xx-xx-xx")];
- REQUIRE(rdata->type == 109);
+ REQUIRE(rdata->type == dns_rdatatype_eui64);
REQUIRE(rdata->length == 8);
UNUSED(tctx);
fromwire_eui64(ARGS_FROMWIRE) {
isc_region_t sregion;
- REQUIRE(type == 109);
+ REQUIRE(type == dns_rdatatype_eui64);
UNUSED(type);
UNUSED(options);
static inline isc_result_t
towire_eui64(ARGS_TOWIRE) {
- REQUIRE(rdata->type == 109);
+ REQUIRE(rdata->type == dns_rdatatype_eui64);
REQUIRE(rdata->length == 8);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 109);
+ REQUIRE(rdata1->type == dns_rdatatype_eui64);
REQUIRE(rdata1->length == 8);
REQUIRE(rdata2->length == 8);
fromstruct_eui64(ARGS_FROMSTRUCT) {
dns_rdata_eui64_t *eui64 = source;
- REQUIRE(type == 109);
+ REQUIRE(type == dns_rdatatype_eui64);
REQUIRE(source != NULL);
REQUIRE(eui64->common.rdtype == type);
REQUIRE(eui64->common.rdclass == rdclass);
tostruct_eui64(ARGS_TOSTRUCT) {
dns_rdata_eui64_t *eui64 = target;
- REQUIRE(rdata->type == 109);
+ REQUIRE(rdata->type == dns_rdatatype_eui64);
REQUIRE(target != NULL);
REQUIRE(rdata->length == 8);
dns_rdata_eui64_t *eui64 = source;
REQUIRE(source != NULL);
- REQUIRE(eui64->common.rdtype == 109);
+ REQUIRE(eui64->common.rdtype == dns_rdatatype_eui64);
return;
}
static inline isc_result_t
additionaldata_eui64(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 109);
+ REQUIRE(rdata->type == dns_rdatatype_eui64);
REQUIRE(rdata->length == 8);
UNUSED(rdata);
digest_eui64(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 109);
+ REQUIRE(rdata->type == dns_rdatatype_eui64);
REQUIRE(rdata->length == 8);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_eui64(ARGS_CHECKOWNER) {
- REQUIRE(type == 109);
+ REQUIRE(type == dns_rdatatype_eui64);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_eui64(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 109);
+ REQUIRE(rdata->type == dns_rdatatype_eui64);
REQUIRE(rdata->length == 8);
UNUSED(rdata);
isc_token_t token;
int i;
- REQUIRE(type == 27);
+ REQUIRE(type == dns_rdatatype_gpos);
UNUSED(type);
UNUSED(rdclass);
isc_region_t region;
int i;
- REQUIRE(rdata->type == 27);
+ REQUIRE(rdata->type == dns_rdatatype_gpos);
REQUIRE(rdata->length != 0);
UNUSED(tctx);
fromwire_gpos(ARGS_FROMWIRE) {
int i;
- REQUIRE(type == 27);
+ REQUIRE(type == dns_rdatatype_gpos);
UNUSED(type);
UNUSED(dctx);
static inline isc_result_t
towire_gpos(ARGS_TOWIRE) {
- REQUIRE(rdata->type == 27);
+ REQUIRE(rdata->type == dns_rdatatype_gpos);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 27);
+ REQUIRE(rdata1->type == dns_rdatatype_gpos);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_gpos(ARGS_FROMSTRUCT) {
dns_rdata_gpos_t *gpos = source;
- REQUIRE(type == 27);
+ REQUIRE(type == dns_rdatatype_gpos);
REQUIRE(source != NULL);
REQUIRE(gpos->common.rdtype == type);
REQUIRE(gpos->common.rdclass == rdclass);
dns_rdata_gpos_t *gpos = target;
isc_region_t region;
- REQUIRE(rdata->type == 27);
+ REQUIRE(rdata->type == dns_rdatatype_gpos);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_gpos_t *gpos = source;
REQUIRE(source != NULL);
- REQUIRE(gpos->common.rdtype == 27);
+ REQUIRE(gpos->common.rdtype == dns_rdatatype_gpos);
if (gpos->mctx == NULL)
return;
static inline isc_result_t
additionaldata_gpos(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 27);
+ REQUIRE(rdata->type == dns_rdatatype_gpos);
UNUSED(rdata);
UNUSED(add);
digest_gpos(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 27);
+ REQUIRE(rdata->type == dns_rdatatype_gpos);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_gpos(ARGS_CHECKOWNER) {
- REQUIRE(type == 27);
+ REQUIRE(type == dns_rdatatype_gpos);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_gpos(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 27);
+ REQUIRE(rdata->type == dns_rdatatype_gpos);
UNUSED(rdata);
UNUSED(owner);
UNUSED(options);
UNUSED(callbacks);
- REQUIRE(type == 13);
+ REQUIRE(type == dns_rdatatype_hinfo);
for (i = 0; i < 2; i++) {
RETERR(isc_lex_getmastertoken(lexer, &token,
UNUSED(tctx);
- REQUIRE(rdata->type == 13);
+ REQUIRE(rdata->type == dns_rdatatype_hinfo);
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, ®ion);
static inline isc_result_t
fromwire_hinfo(ARGS_FROMWIRE) {
- REQUIRE(type == 13);
+ REQUIRE(type == dns_rdatatype_hinfo);
UNUSED(type);
UNUSED(dctx);
UNUSED(cctx);
- REQUIRE(rdata->type == 13);
+ REQUIRE(rdata->type == dns_rdatatype_hinfo);
REQUIRE(rdata->length != 0);
return (mem_tobuffer(target, rdata->data, rdata->length));
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 13);
+ REQUIRE(rdata1->type == dns_rdatatype_hinfo);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_hinfo(ARGS_FROMSTRUCT) {
dns_rdata_hinfo_t *hinfo = source;
- REQUIRE(type == 13);
+ REQUIRE(type == dns_rdatatype_hinfo);
REQUIRE(source != NULL);
REQUIRE(hinfo->common.rdtype == type);
REQUIRE(hinfo->common.rdclass == rdclass);
dns_rdata_hinfo_t *hinfo = target;
isc_region_t region;
- REQUIRE(rdata->type == 13);
+ REQUIRE(rdata->type == dns_rdatatype_hinfo);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
static inline isc_result_t
additionaldata_hinfo(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 13);
+ REQUIRE(rdata->type == dns_rdatatype_hinfo);
UNUSED(add);
UNUSED(arg);
digest_hinfo(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 13);
+ REQUIRE(rdata->type == dns_rdatatype_hinfo);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_hinfo(ARGS_CHECKOWNER) {
- REQUIRE(type == 13);
+ REQUIRE(type == dns_rdatatype_hinfo);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_hinfo(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 13);
+ REQUIRE(rdata->type == dns_rdatatype_hinfo);
UNUSED(rdata);
UNUSED(owner);
unsigned char *start;
size_t len;
- REQUIRE(type == 55);
+ REQUIRE(type == dns_rdatatype_hip);
UNUSED(type);
UNUSED(rdclass);
unsigned char algorithm;
char buf[sizeof("225 ")];
- REQUIRE(rdata->type == 55);
+ REQUIRE(rdata->type == dns_rdatatype_hip);
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, ®ion);
isc_uint8_t hit_len;
isc_uint16_t key_len;
- REQUIRE(type == 55);
+ REQUIRE(type == dns_rdatatype_hip);
UNUSED(type);
UNUSED(rdclass);
towire_hip(ARGS_TOWIRE) {
isc_region_t region;
- REQUIRE(rdata->type == 55);
+ REQUIRE(rdata->type == dns_rdatatype_hip);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 55);
+ REQUIRE(rdata1->type == dns_rdatatype_hip);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_hip_t myhip;
isc_result_t result;
- REQUIRE(type == 55);
+ REQUIRE(type == dns_rdatatype_hip);
REQUIRE(source != NULL);
REQUIRE(hip->common.rdtype == type);
REQUIRE(hip->common.rdclass == rdclass);
isc_region_t region;
dns_rdata_hip_t *hip = target;
- REQUIRE(rdata->type == 55);
+ REQUIRE(rdata->type == dns_rdatatype_hip);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
UNUSED(add);
UNUSED(arg);
- REQUIRE(rdata->type == 55);
+ REQUIRE(rdata->type == dns_rdatatype_hip);
return (ISC_R_SUCCESS);
}
digest_hip(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 55);
+ REQUIRE(rdata->type == dns_rdatatype_hip);
dns_rdata_toregion(rdata, &r);
return ((digest)(arg, &r));
static inline isc_boolean_t
checkowner_hip(ARGS_CHECKOWNER) {
- REQUIRE(type == 55);
+ REQUIRE(type == dns_rdatatype_hip);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_hip(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 55);
+ REQUIRE(rdata->type == dns_rdatatype_hip);
UNUSED(rdata);
UNUSED(owner);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 55);
+ REQUIRE(rdata1->type == dns_rdatatype_hip);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
unsigned char addr6[16];
isc_region_t region;
- REQUIRE(type == 45);
+ REQUIRE(type == dns_rdatatype_ipseckey);
UNUSED(type);
UNUSED(rdclass);
unsigned short num;
unsigned short gateway;
- REQUIRE(rdata->type == 45);
+ REQUIRE(rdata->type == dns_rdatatype_ipseckey);
REQUIRE(rdata->length >= 3);
dns_name_init(&name, NULL);
dns_name_t name;
isc_region_t region;
- REQUIRE(type == 45);
+ REQUIRE(type == dns_rdatatype_ipseckey);
UNUSED(type);
UNUSED(rdclass);
towire_ipseckey(ARGS_TOWIRE) {
isc_region_t region;
- REQUIRE(rdata->type == 45);
+ REQUIRE(rdata->type == dns_rdatatype_ipseckey);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 45);
+ REQUIRE(rdata1->type == dns_rdatatype_ipseckey);
REQUIRE(rdata1->length >= 3);
REQUIRE(rdata2->length >= 3);
isc_region_t region;
isc_uint32_t n;
- REQUIRE(type == 45);
+ REQUIRE(type == dns_rdatatype_ipseckey);
REQUIRE(source != NULL);
REQUIRE(ipseckey->common.rdtype == type);
REQUIRE(ipseckey->common.rdclass == rdclass);
dns_name_t name;
isc_uint32_t n;
- REQUIRE(rdata->type == 45);
+ REQUIRE(rdata->type == dns_rdatatype_ipseckey);
REQUIRE(target != NULL);
REQUIRE(rdata->length >= 3);
dns_rdata_ipseckey_t *ipseckey = source;
REQUIRE(source != NULL);
- REQUIRE(ipseckey->common.rdtype == 45);
+ REQUIRE(ipseckey->common.rdtype == dns_rdatatype_ipseckey);
if (ipseckey->mctx == NULL)
return;
static inline isc_result_t
additionaldata_ipseckey(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 45);
+ REQUIRE(rdata->type == dns_rdatatype_ipseckey);
UNUSED(rdata);
UNUSED(add);
digest_ipseckey(ARGS_DIGEST) {
isc_region_t region;
- REQUIRE(rdata->type == 45);
+ REQUIRE(rdata->type == dns_rdatatype_ipseckey);
dns_rdata_toregion(rdata, ®ion);
return ((digest)(arg, ®ion));
static inline isc_boolean_t
checkowner_ipseckey(ARGS_CHECKOWNER) {
- REQUIRE(type == 45);
+ REQUIRE(type == dns_rdatatype_ipseckey);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_ipseckey(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 45);
+ REQUIRE(rdata->type == dns_rdatatype_ipseckey);
UNUSED(rdata);
UNUSED(owner);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 45);
+ REQUIRE(rdata1->type == dns_rdatatype_ipseckey);
REQUIRE(rdata1->length >= 3);
REQUIRE(rdata2->length >= 3);
fromtext_isdn(ARGS_FROMTEXT) {
isc_token_t token;
- REQUIRE(type == 20);
+ REQUIRE(type == dns_rdatatype_isdn);
UNUSED(type);
UNUSED(rdclass);
totext_isdn(ARGS_TOTEXT) {
isc_region_t region;
- REQUIRE(rdata->type == 20);
+ REQUIRE(rdata->type == dns_rdatatype_isdn);
REQUIRE(rdata->length != 0);
UNUSED(tctx);
static inline isc_result_t
fromwire_isdn(ARGS_FROMWIRE) {
- REQUIRE(type == 20);
+ REQUIRE(type == dns_rdatatype_isdn);
UNUSED(type);
UNUSED(dctx);
towire_isdn(ARGS_TOWIRE) {
UNUSED(cctx);
- REQUIRE(rdata->type == 20);
+ REQUIRE(rdata->type == dns_rdatatype_isdn);
REQUIRE(rdata->length != 0);
return (mem_tobuffer(target, rdata->data, rdata->length));
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 20);
+ REQUIRE(rdata1->type == dns_rdatatype_isdn);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_isdn(ARGS_FROMSTRUCT) {
dns_rdata_isdn_t *isdn = source;
- REQUIRE(type == 20);
+ REQUIRE(type == dns_rdatatype_isdn);
REQUIRE(source != NULL);
REQUIRE(isdn->common.rdtype == type);
REQUIRE(isdn->common.rdclass == rdclass);
dns_rdata_isdn_t *isdn = target;
isc_region_t r;
- REQUIRE(rdata->type == 20);
+ REQUIRE(rdata->type == dns_rdatatype_isdn);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
static inline isc_result_t
additionaldata_isdn(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 20);
+ REQUIRE(rdata->type == dns_rdatatype_isdn);
UNUSED(rdata);
UNUSED(add);
digest_isdn(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 20);
+ REQUIRE(rdata->type == dns_rdatatype_isdn);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_isdn(ARGS_CHECKOWNER) {
- REQUIRE(type == 20);
+ REQUIRE(type == dns_rdatatype_isdn);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_isdn(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 20);
+ REQUIRE(rdata->type == dns_rdatatype_isdn);
UNUSED(rdata);
UNUSED(owner);
dns_secproto_t proto;
dns_keyflags_t flags;
- REQUIRE(type == 25);
+ REQUIRE(type == dns_rdatatype_key);
UNUSED(type);
UNUSED(rdclass);
unsigned char algorithm;
char namebuf[DNS_NAME_FORMATSIZE];
- REQUIRE(rdata->type == 25);
+ REQUIRE(rdata->type == dns_rdatatype_key);
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, &sr);
unsigned char algorithm;
isc_region_t sr;
- REQUIRE(type == 25);
+ REQUIRE(type == dns_rdatatype_key);
UNUSED(type);
UNUSED(rdclass);
towire_key(ARGS_TOWIRE) {
isc_region_t sr;
- REQUIRE(rdata->type == 25);
+ REQUIRE(rdata->type == dns_rdatatype_key);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 25);
+ REQUIRE(rdata1->type == dns_rdatatype_key);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_key(ARGS_FROMSTRUCT) {
dns_rdata_key_t *key = source;
- REQUIRE(type == 25);
+ REQUIRE(type == dns_rdatatype_key);
REQUIRE(source != NULL);
REQUIRE(key->common.rdtype == type);
REQUIRE(key->common.rdclass == rdclass);
dns_rdata_key_t *key = target;
isc_region_t sr;
- REQUIRE(rdata->type == 25);
+ REQUIRE(rdata->type == dns_rdatatype_key);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_key_t *key = (dns_rdata_key_t *) source;
REQUIRE(source != NULL);
- REQUIRE(key->common.rdtype == 25);
+ REQUIRE(key->common.rdtype == dns_rdatatype_key);
if (key->mctx == NULL)
return;
static inline isc_result_t
additionaldata_key(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 25);
+ REQUIRE(rdata->type == dns_rdatatype_key);
UNUSED(rdata);
UNUSED(add);
digest_key(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 25);
+ REQUIRE(rdata->type == dns_rdatatype_key);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_key(ARGS_CHECKOWNER) {
- REQUIRE(type == 25);
+ REQUIRE(type == dns_rdatatype_key);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_key(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 25);
+ REQUIRE(rdata->type == dns_rdatatype_key);
UNUSED(rdata);
UNUSED(owner);
dns_keyflags_t flags;
isc_uint32_t refresh, addhd, removehd;
- REQUIRE(type == 65533);
+ REQUIRE(type == dns_rdatatype_keydata);
UNUSED(type);
UNUSED(rdclass);
char algbuf[DNS_NAME_FORMATSIZE];
const char *keyinfo;
- REQUIRE(rdata->type == 65533);
+ REQUIRE(rdata->type == dns_rdatatype_keydata);
if ((tctx->flags & DNS_STYLEFLAG_KEYDATA) == 0 || rdata->length < 16)
return (unknown_totext(rdata, tctx, target));
fromwire_keydata(ARGS_FROMWIRE) {
isc_region_t sr;
- REQUIRE(type == 65533);
+ REQUIRE(type == dns_rdatatype_keydata);
UNUSED(type);
UNUSED(rdclass);
towire_keydata(ARGS_TOWIRE) {
isc_region_t sr;
- REQUIRE(rdata->type == 65533);
+ REQUIRE(rdata->type == dns_rdatatype_keydata);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 65533);
+ REQUIRE(rdata1->type == dns_rdatatype_keydata);
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
fromstruct_keydata(ARGS_FROMSTRUCT) {
dns_rdata_keydata_t *keydata = source;
- REQUIRE(type == 65533);
+ REQUIRE(type == dns_rdatatype_keydata);
REQUIRE(source != NULL);
REQUIRE(keydata->common.rdtype == type);
REQUIRE(keydata->common.rdclass == rdclass);
dns_rdata_keydata_t *keydata = target;
isc_region_t sr;
- REQUIRE(rdata->type == 65533);
+ REQUIRE(rdata->type == dns_rdatatype_keydata);
REQUIRE(target != NULL);
keydata->common.rdclass = rdata->rdclass;
dns_rdata_keydata_t *keydata = (dns_rdata_keydata_t *) source;
REQUIRE(source != NULL);
- REQUIRE(keydata->common.rdtype == 65533);
+ REQUIRE(keydata->common.rdtype == dns_rdatatype_keydata);
if (keydata->mctx == NULL)
return;
static inline isc_result_t
additionaldata_keydata(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 65533);
+ REQUIRE(rdata->type == dns_rdatatype_keydata);
UNUSED(rdata);
UNUSED(add);
digest_keydata(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 65533);
+ REQUIRE(rdata->type == dns_rdatatype_keydata);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_keydata(ARGS_CHECKOWNER) {
- REQUIRE(type == 65533);
+ REQUIRE(type == dns_rdatatype_keydata);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_keydata(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 65533);
+ REQUIRE(rdata->type == dns_rdatatype_keydata);
UNUSED(rdata);
UNUSED(owner);
struct in_addr addr;
isc_region_t region;
- REQUIRE(type == 105);
+ REQUIRE(type == dns_rdatatype_l32);
UNUSED(type);
UNUSED(rdclass);
char buf[sizeof("65000")];
unsigned short num;
- REQUIRE(rdata->type == 105);
+ REQUIRE(rdata->type == dns_rdatatype_l32);
REQUIRE(rdata->length == 6);
UNUSED(tctx);
fromwire_l32(ARGS_FROMWIRE) {
isc_region_t sregion;
- REQUIRE(type == 105);
+ REQUIRE(type == dns_rdatatype_l32);
UNUSED(type);
UNUSED(options);
static inline isc_result_t
towire_l32(ARGS_TOWIRE) {
- REQUIRE(rdata->type == 105);
+ REQUIRE(rdata->type == dns_rdatatype_l32);
REQUIRE(rdata->length == 6);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 105);
+ REQUIRE(rdata1->type == dns_rdatatype_l32);
REQUIRE(rdata1->length == 6);
REQUIRE(rdata2->length == 6);
dns_rdata_l32_t *l32 = source;
isc_uint32_t n;
- REQUIRE(type == 105);
+ REQUIRE(type == dns_rdatatype_l32);
REQUIRE(source != NULL);
REQUIRE(l32->common.rdtype == type);
REQUIRE(l32->common.rdclass == rdclass);
dns_rdata_l32_t *l32 = target;
isc_uint32_t n;
- REQUIRE(rdata->type == 105);
+ REQUIRE(rdata->type == dns_rdatatype_l32);
REQUIRE(target != NULL);
REQUIRE(rdata->length == 6);
dns_rdata_l32_t *l32 = source;
REQUIRE(source != NULL);
- REQUIRE(l32->common.rdtype == 105);
+ REQUIRE(l32->common.rdtype == dns_rdatatype_l32);
return;
}
static inline isc_result_t
additionaldata_l32(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 105);
+ REQUIRE(rdata->type == dns_rdatatype_l32);
REQUIRE(rdata->length == 6);
UNUSED(rdata);
digest_l32(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 105);
+ REQUIRE(rdata->type == dns_rdatatype_l32);
REQUIRE(rdata->length == 6);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_l32(ARGS_CHECKOWNER) {
- REQUIRE(type == 105);
+ REQUIRE(type == dns_rdatatype_l32);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_l32(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 105);
+ REQUIRE(rdata->type == dns_rdatatype_l32);
REQUIRE(rdata->length == 6);
UNUSED(rdata);
isc_token_t token;
unsigned char locator[NS_LOCATORSZ];
- REQUIRE(type == 106);
+ REQUIRE(type == dns_rdatatype_l64);
UNUSED(type);
UNUSED(rdclass);
char buf[sizeof("xxxx:xxxx:xxxx:xxxx")];
unsigned short num;
- REQUIRE(rdata->type == 106);
+ REQUIRE(rdata->type == dns_rdatatype_l64);
REQUIRE(rdata->length == 10);
UNUSED(tctx);
fromwire_l64(ARGS_FROMWIRE) {
isc_region_t sregion;
- REQUIRE(type == 106);
+ REQUIRE(type == dns_rdatatype_l64);
UNUSED(type);
UNUSED(options);
static inline isc_result_t
towire_l64(ARGS_TOWIRE) {
- REQUIRE(rdata->type == 106);
+ REQUIRE(rdata->type == dns_rdatatype_l64);
REQUIRE(rdata->length == 10);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 106);
+ REQUIRE(rdata1->type == dns_rdatatype_l64);
REQUIRE(rdata1->length == 10);
REQUIRE(rdata2->length == 10);
fromstruct_l64(ARGS_FROMSTRUCT) {
dns_rdata_l64_t *l64 = source;
- REQUIRE(type == 106);
+ REQUIRE(type == dns_rdatatype_l64);
REQUIRE(source != NULL);
REQUIRE(l64->common.rdtype == type);
REQUIRE(l64->common.rdclass == rdclass);
isc_region_t region;
dns_rdata_l64_t *l64 = target;
- REQUIRE(rdata->type == 106);
+ REQUIRE(rdata->type == dns_rdatatype_l64);
REQUIRE(target != NULL);
REQUIRE(rdata->length == 10);
dns_rdata_l64_t *l64 = source;
REQUIRE(source != NULL);
- REQUIRE(l64->common.rdtype == 106);
+ REQUIRE(l64->common.rdtype == dns_rdatatype_l64);
return;
}
static inline isc_result_t
additionaldata_l64(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 106);
+ REQUIRE(rdata->type == dns_rdatatype_l64);
REQUIRE(rdata->length == 10);
UNUSED(rdata);
digest_l64(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 106);
+ REQUIRE(rdata->type == dns_rdatatype_l64);
REQUIRE(rdata->length == 10);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_l64(ARGS_CHECKOWNER) {
- REQUIRE(type == 106);
+ REQUIRE(type == dns_rdatatype_l64);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_l64(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 106);
+ REQUIRE(rdata->type == dns_rdatatype_l64);
REQUIRE(rdata->length == 10);
UNUSED(rdata);
unsigned long longitude;
unsigned long altitude;
- REQUIRE(type == 29);
+ REQUIRE(type == dns_rdatatype_loc);
UNUSED(type);
UNUSED(rdclass);
UNUSED(tctx);
- REQUIRE(rdata->type == 29);
+ REQUIRE(rdata->type == dns_rdatatype_loc);
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, &sr);
unsigned long latitude;
unsigned long longitude;
- REQUIRE(type == 29);
+ REQUIRE(type == dns_rdatatype_loc);
UNUSED(type);
UNUSED(rdclass);
towire_loc(ARGS_TOWIRE) {
UNUSED(cctx);
- REQUIRE(rdata->type == 29);
+ REQUIRE(rdata->type == dns_rdatatype_loc);
REQUIRE(rdata->length != 0);
return (mem_tobuffer(target, rdata->data, rdata->length));
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 29);
+ REQUIRE(rdata1->type == dns_rdatatype_loc);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_loc_t *loc = source;
isc_uint8_t c;
- REQUIRE(type == 29);
+ REQUIRE(type == dns_rdatatype_loc);
REQUIRE(source != NULL);
REQUIRE(loc->common.rdtype == type);
REQUIRE(loc->common.rdclass == rdclass);
isc_region_t r;
isc_uint8_t version;
- REQUIRE(rdata->type == 29);
+ REQUIRE(rdata->type == dns_rdatatype_loc);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_loc_t *loc = source;
REQUIRE(source != NULL);
- REQUIRE(loc->common.rdtype == 29);
+ REQUIRE(loc->common.rdtype == dns_rdatatype_loc);
UNUSED(source);
UNUSED(loc);
static inline isc_result_t
additionaldata_loc(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 29);
+ REQUIRE(rdata->type == dns_rdatatype_loc);
UNUSED(rdata);
UNUSED(add);
digest_loc(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 29);
+ REQUIRE(rdata->type == dns_rdatatype_loc);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_loc(ARGS_CHECKOWNER) {
- REQUIRE(type == 29);
+ REQUIRE(type == dns_rdatatype_loc);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_loc(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 29);
+ REQUIRE(rdata->type == dns_rdatatype_loc);
UNUSED(rdata);
UNUSED(owner);
dns_name_t name;
isc_buffer_t buffer;
- REQUIRE(type == 107);
+ REQUIRE(type == dns_rdatatype_lp);
UNUSED(type);
UNUSED(rdclass);
char buf[sizeof("64000")];
unsigned short num;
- REQUIRE(rdata->type == 107);
+ REQUIRE(rdata->type == dns_rdatatype_lp);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
dns_name_t name;
isc_region_t sregion;
- REQUIRE(type == 107);
+ REQUIRE(type == dns_rdatatype_lp);
UNUSED(type);
UNUSED(rdclass);
static inline isc_result_t
towire_lp(ARGS_TOWIRE) {
- REQUIRE(rdata->type == 107);
+ REQUIRE(rdata->type == dns_rdatatype_lp);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 107);
+ REQUIRE(rdata1->type == dns_rdatatype_lp);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_lp_t *lp = source;
isc_region_t region;
- REQUIRE(type == 107);
+ REQUIRE(type == dns_rdatatype_lp);
REQUIRE(source != NULL);
REQUIRE(lp->common.rdtype == type);
REQUIRE(lp->common.rdclass == rdclass);
dns_rdata_lp_t *lp = target;
dns_name_t name;
- REQUIRE(rdata->type == 107);
+ REQUIRE(rdata->type == dns_rdatatype_lp);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_lp_t *lp = source;
REQUIRE(source != NULL);
- REQUIRE(lp->common.rdtype == 107);
+ REQUIRE(lp->common.rdtype == dns_rdatatype_lp);
if (lp->mctx == NULL)
return;
isc_region_t region;
isc_result_t result;
- REQUIRE(rdata->type == 107);
+ REQUIRE(rdata->type == dns_rdatatype_lp);
dns_name_init(&name, offsets);
dns_rdata_toregion(rdata, ®ion);
digest_lp(ARGS_DIGEST) {
isc_region_t region;
- REQUIRE(rdata->type == 107);
+ REQUIRE(rdata->type == dns_rdatatype_lp);
dns_rdata_toregion(rdata, ®ion);
return ((digest)(arg, ®ion));
static inline isc_boolean_t
checkowner_lp(ARGS_CHECKOWNER) {
- REQUIRE(type == 107);
+ REQUIRE(type == dns_rdatatype_lp);
UNUSED(type);
UNUSED(rdclass);
static inline isc_boolean_t
checknames_lp(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 107);
+ REQUIRE(rdata->type == dns_rdatatype_lp);
UNUSED(bad);
UNUSED(owner);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 107);
+ REQUIRE(rdata1->type == dns_rdatatype_lp);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_name_t name;
isc_buffer_t buffer;
- REQUIRE(type == 7);
+ REQUIRE(type == dns_rdatatype_mb);
UNUSED(type);
UNUSED(rdclass);
dns_name_t prefix;
isc_boolean_t sub;
- REQUIRE(rdata->type == 7);
+ REQUIRE(rdata->type == dns_rdatatype_mb);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
fromwire_mb(ARGS_FROMWIRE) {
dns_name_t name;
- REQUIRE(type == 7);
+ REQUIRE(type == dns_rdatatype_mb);
UNUSED(type);
UNUSED(rdclass);
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 7);
+ REQUIRE(rdata->type == dns_rdatatype_mb);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_GLOBAL14);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 7);
+ REQUIRE(rdata1->type == dns_rdatatype_mb);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_mb_t *mb = source;
isc_region_t region;
- REQUIRE(type == 7);
+ REQUIRE(type == dns_rdatatype_mb);
REQUIRE(source != NULL);
REQUIRE(mb->common.rdtype == type);
REQUIRE(mb->common.rdclass == rdclass);
dns_rdata_mb_t *mb = target;
dns_name_t name;
- REQUIRE(rdata->type == 7);
+ REQUIRE(rdata->type == dns_rdatatype_mb);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 7);
+ REQUIRE(rdata->type == dns_rdatatype_mb);
dns_name_init(&name, offsets);
dns_rdata_toregion(rdata, ®ion);
isc_region_t r;
dns_name_t name;
- REQUIRE(rdata->type == 7);
+ REQUIRE(rdata->type == dns_rdatatype_mb);
dns_rdata_toregion(rdata, &r);
dns_name_init(&name, NULL);
static inline isc_boolean_t
checkowner_mb(ARGS_CHECKOWNER) {
- REQUIRE(type == 7);
+ REQUIRE(type == dns_rdatatype_mb);
UNUSED(type);
UNUSED(rdclass);
static inline isc_boolean_t
checknames_mb(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 7);
+ REQUIRE(rdata->type == dns_rdatatype_mb);
UNUSED(rdata);
UNUSED(owner);
dns_name_t name;
isc_buffer_t buffer;
- REQUIRE(type == 3);
+ REQUIRE(type == dns_rdatatype_md);
UNUSED(type);
UNUSED(rdclass);
dns_name_t prefix;
isc_boolean_t sub;
- REQUIRE(rdata->type == 3);
+ REQUIRE(rdata->type == dns_rdatatype_md);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
fromwire_md(ARGS_FROMWIRE) {
dns_name_t name;
- REQUIRE(type == 3);
+ REQUIRE(type == dns_rdatatype_md);
UNUSED(type);
UNUSED(rdclass);
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 3);
+ REQUIRE(rdata->type == dns_rdatatype_md);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_GLOBAL14);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 3);
+ REQUIRE(rdata1->type == dns_rdatatype_md);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_md_t *md = source;
isc_region_t region;
- REQUIRE(type == 3);
+ REQUIRE(type == dns_rdatatype_md);
REQUIRE(source != NULL);
REQUIRE(md->common.rdtype == type);
REQUIRE(md->common.rdclass == rdclass);
isc_region_t r;
dns_name_t name;
- REQUIRE(rdata->type == 3);
+ REQUIRE(rdata->type == dns_rdatatype_md);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_md_t *md = source;
REQUIRE(source != NULL);
- REQUIRE(md->common.rdtype == 3);
+ REQUIRE(md->common.rdtype == dns_rdatatype_md);
if (md->mctx == NULL)
return;
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 3);
+ REQUIRE(rdata->type == dns_rdatatype_md);
dns_name_init(&name, offsets);
dns_rdata_toregion(rdata, ®ion);
isc_region_t r;
dns_name_t name;
- REQUIRE(rdata->type == 3);
+ REQUIRE(rdata->type == dns_rdatatype_md);
dns_rdata_toregion(rdata, &r);
dns_name_init(&name, NULL);
static inline isc_boolean_t
checkowner_md(ARGS_CHECKOWNER) {
- REQUIRE(type == 3);
+ REQUIRE(type == dns_rdatatype_md);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_md(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 3);
+ REQUIRE(rdata->type == dns_rdatatype_md);
UNUSED(rdata);
UNUSED(owner);
dns_name_t name;
isc_buffer_t buffer;
- REQUIRE(type == 4);
+ REQUIRE(type == dns_rdatatype_mf);
UNUSED(type);
UNUSED(rdclass);
dns_name_t prefix;
isc_boolean_t sub;
- REQUIRE(rdata->type == 4);
+ REQUIRE(rdata->type == dns_rdatatype_mf);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
fromwire_mf(ARGS_FROMWIRE) {
dns_name_t name;
- REQUIRE(type == 4);
+ REQUIRE(type == dns_rdatatype_mf);
UNUSED(type);
UNUSED(rdclass);
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 4);
+ REQUIRE(rdata->type == dns_rdatatype_mf);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_GLOBAL14);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 4);
+ REQUIRE(rdata1->type == dns_rdatatype_mf);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_mf_t *mf = source;
isc_region_t region;
- REQUIRE(type == 4);
+ REQUIRE(type == dns_rdatatype_mf);
REQUIRE(source != NULL);
REQUIRE(mf->common.rdtype == type);
REQUIRE(mf->common.rdclass == rdclass);
isc_region_t r;
dns_name_t name;
- REQUIRE(rdata->type == 4);
+ REQUIRE(rdata->type == dns_rdatatype_mf);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_mf_t *mf = source;
REQUIRE(source != NULL);
- REQUIRE(mf->common.rdtype == 4);
+ REQUIRE(mf->common.rdtype == dns_rdatatype_mf);
if (mf->mctx == NULL)
return;
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 4);
+ REQUIRE(rdata->type == dns_rdatatype_mf);
dns_name_init(&name, offsets);
dns_rdata_toregion(rdata, ®ion);
isc_region_t r;
dns_name_t name;
- REQUIRE(rdata->type == 4);
+ REQUIRE(rdata->type == dns_rdatatype_mf);
dns_rdata_toregion(rdata, &r);
dns_name_init(&name, NULL);
static inline isc_boolean_t
checkowner_mf(ARGS_CHECKOWNER) {
- REQUIRE(type == 4);
+ REQUIRE(type == dns_rdatatype_mf);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_mf(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 4);
+ REQUIRE(rdata->type == dns_rdatatype_mf);
UNUSED(rdata);
UNUSED(owner);
dns_name_t name;
isc_buffer_t buffer;
- REQUIRE(type == 8);
+ REQUIRE(type == dns_rdatatype_mg);
UNUSED(type);
UNUSED(rdclass);
dns_name_t prefix;
isc_boolean_t sub;
- REQUIRE(rdata->type == 8);
+ REQUIRE(rdata->type == dns_rdatatype_mg);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
fromwire_mg(ARGS_FROMWIRE) {
dns_name_t name;
- REQUIRE(type == 8);
+ REQUIRE(type == dns_rdatatype_mg);
UNUSED(type);
UNUSED(rdclass);
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 8);
+ REQUIRE(rdata->type == dns_rdatatype_mg);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_GLOBAL14);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 8);
+ REQUIRE(rdata1->type == dns_rdatatype_mg);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_mg_t *mg = source;
isc_region_t region;
- REQUIRE(type == 8);
+ REQUIRE(type == dns_rdatatype_mg);
REQUIRE(source != NULL);
REQUIRE(mg->common.rdtype == type);
REQUIRE(mg->common.rdclass == rdclass);
dns_rdata_mg_t *mg = target;
dns_name_t name;
- REQUIRE(rdata->type == 8);
+ REQUIRE(rdata->type == dns_rdatatype_mg);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_mg_t *mg = source;
REQUIRE(source != NULL);
- REQUIRE(mg->common.rdtype == 8);
+ REQUIRE(mg->common.rdtype == dns_rdatatype_mg);
if (mg->mctx == NULL)
return;
static inline isc_result_t
additionaldata_mg(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 8);
+ REQUIRE(rdata->type == dns_rdatatype_mg);
UNUSED(add);
UNUSED(arg);
isc_region_t r;
dns_name_t name;
- REQUIRE(rdata->type == 8);
+ REQUIRE(rdata->type == dns_rdatatype_mg);
dns_rdata_toregion(rdata, &r);
dns_name_init(&name, NULL);
static inline isc_boolean_t
checkowner_mg(ARGS_CHECKOWNER) {
- REQUIRE(type == 8);
+ REQUIRE(type == dns_rdatatype_mg);
UNUSED(type);
UNUSED(rdclass);
static inline isc_boolean_t
checknames_mg(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 8);
+ REQUIRE(rdata->type == dns_rdatatype_mg);
UNUSED(rdata);
UNUSED(owner);
int i;
isc_boolean_t ok;
- REQUIRE(type == 14);
+ REQUIRE(type == dns_rdatatype_minfo);
UNUSED(type);
UNUSED(rdclass);
dns_name_t prefix;
isc_boolean_t sub;
- REQUIRE(rdata->type == 14);
+ REQUIRE(rdata->type == dns_rdatatype_minfo);
REQUIRE(rdata->length != 0);
dns_name_init(&rmail, NULL);
dns_name_t rmail;
dns_name_t email;
- REQUIRE(type == 14);
+ REQUIRE(type == dns_rdatatype_minfo);
UNUSED(type);
UNUSED(rdclass);
dns_offsets_t roffsets;
dns_offsets_t eoffsets;
- REQUIRE(rdata->type == 14);
+ REQUIRE(rdata->type == dns_rdatatype_minfo);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_GLOBAL14);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 14);
+ REQUIRE(rdata1->type == dns_rdatatype_minfo);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_minfo_t *minfo = source;
isc_region_t region;
- REQUIRE(type == 14);
+ REQUIRE(type == dns_rdatatype_minfo);
REQUIRE(source != NULL);
REQUIRE(minfo->common.rdtype == type);
REQUIRE(minfo->common.rdclass == rdclass);
dns_name_t name;
isc_result_t result;
- REQUIRE(rdata->type == 14);
+ REQUIRE(rdata->type == dns_rdatatype_minfo);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_minfo_t *minfo = source;
REQUIRE(source != NULL);
- REQUIRE(minfo->common.rdtype == 14);
+ REQUIRE(minfo->common.rdtype == dns_rdatatype_minfo);
if (minfo->mctx == NULL)
return;
static inline isc_result_t
additionaldata_minfo(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 14);
+ REQUIRE(rdata->type == dns_rdatatype_minfo);
UNUSED(rdata);
UNUSED(add);
dns_name_t name;
isc_result_t result;
- REQUIRE(rdata->type == 14);
+ REQUIRE(rdata->type == dns_rdatatype_minfo);
dns_rdata_toregion(rdata, &r);
dns_name_init(&name, NULL);
static inline isc_boolean_t
checkowner_minfo(ARGS_CHECKOWNER) {
- REQUIRE(type == 14);
+ REQUIRE(type == dns_rdatatype_minfo);
UNUSED(name);
UNUSED(type);
isc_region_t region;
dns_name_t name;
- REQUIRE(rdata->type == 14);
+ REQUIRE(rdata->type == dns_rdatatype_minfo);
UNUSED(owner);
dns_name_t name;
isc_buffer_t buffer;
- REQUIRE(type == 9);
+ REQUIRE(type == dns_rdatatype_mr);
UNUSED(type);
UNUSED(rdclass);
dns_name_t prefix;
isc_boolean_t sub;
- REQUIRE(rdata->type == 9);
+ REQUIRE(rdata->type == dns_rdatatype_mr);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
fromwire_mr(ARGS_FROMWIRE) {
dns_name_t name;
- REQUIRE(type == 9);
+ REQUIRE(type == dns_rdatatype_mr);
UNUSED(type);
UNUSED(rdclass);
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 9);
+ REQUIRE(rdata->type == dns_rdatatype_mr);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_GLOBAL14);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 9);
+ REQUIRE(rdata1->type == dns_rdatatype_mr);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_mr_t *mr = source;
isc_region_t region;
- REQUIRE(type == 9);
+ REQUIRE(type == dns_rdatatype_mr);
REQUIRE(source != NULL);
REQUIRE(mr->common.rdtype == type);
REQUIRE(mr->common.rdclass == rdclass);
dns_rdata_mr_t *mr = target;
dns_name_t name;
- REQUIRE(rdata->type == 9);
+ REQUIRE(rdata->type == dns_rdatatype_mr);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_mr_t *mr = source;
REQUIRE(source != NULL);
- REQUIRE(mr->common.rdtype == 9);
+ REQUIRE(mr->common.rdtype == dns_rdatatype_mr);
if (mr->mctx == NULL)
return;
static inline isc_result_t
additionaldata_mr(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 9);
+ REQUIRE(rdata->type == dns_rdatatype_mr);
UNUSED(rdata);
UNUSED(add);
isc_region_t r;
dns_name_t name;
- REQUIRE(rdata->type == 9);
+ REQUIRE(rdata->type == dns_rdatatype_mr);
dns_rdata_toregion(rdata, &r);
dns_name_init(&name, NULL);
static inline isc_boolean_t
checkowner_mr(ARGS_CHECKOWNER) {
- REQUIRE(type == 9);
+ REQUIRE(type == dns_rdatatype_mr);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_mr(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 9);
+ REQUIRE(rdata->type == dns_rdatatype_mr);
UNUSED(rdata);
UNUSED(owner);
isc_buffer_t buffer;
isc_boolean_t ok;
- REQUIRE(type == 15);
+ REQUIRE(type == dns_rdatatype_mx);
UNUSED(type);
UNUSED(rdclass);
char buf[sizeof("64000")];
unsigned short num;
- REQUIRE(rdata->type == 15);
+ REQUIRE(rdata->type == dns_rdatatype_mx);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
dns_name_t name;
isc_region_t sregion;
- REQUIRE(type == 15);
+ REQUIRE(type == dns_rdatatype_mx);
UNUSED(type);
UNUSED(rdclass);
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 15);
+ REQUIRE(rdata->type == dns_rdatatype_mx);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_GLOBAL14);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 15);
+ REQUIRE(rdata1->type == dns_rdatatype_mx);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_mx_t *mx = source;
isc_region_t region;
- REQUIRE(type == 15);
+ REQUIRE(type == dns_rdatatype_mx);
REQUIRE(source != NULL);
REQUIRE(mx->common.rdtype == type);
REQUIRE(mx->common.rdclass == rdclass);
dns_rdata_mx_t *mx = target;
dns_name_t name;
- REQUIRE(rdata->type == 15);
+ REQUIRE(rdata->type == dns_rdatatype_mx);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_mx_t *mx = source;
REQUIRE(source != NULL);
- REQUIRE(mx->common.rdtype == 15);
+ REQUIRE(mx->common.rdtype == dns_rdatatype_mx);
if (mx->mctx == NULL)
return;
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 15);
+ REQUIRE(rdata->type == dns_rdatatype_mx);
dns_name_init(&name, offsets);
dns_rdata_toregion(rdata, ®ion);
isc_region_t r1, r2;
dns_name_t name;
- REQUIRE(rdata->type == 15);
+ REQUIRE(rdata->type == dns_rdatatype_mx);
dns_rdata_toregion(rdata, &r1);
r2 = r1;
static inline isc_boolean_t
checkowner_mx(ARGS_CHECKOWNER) {
- REQUIRE(type == 15);
+ REQUIRE(type == dns_rdatatype_mx);
UNUSED(type);
UNUSED(rdclass);
isc_region_t region;
dns_name_t name;
- REQUIRE(rdata->type == 15);
+ REQUIRE(rdata->type == dns_rdatatype_mx);
UNUSED(owner);
isc_buffer_t buffer;
unsigned char *regex;
- REQUIRE(type == 35);
+ REQUIRE(type == dns_rdatatype_naptr);
UNUSED(type);
UNUSED(rdclass);
char buf[sizeof("64000")];
unsigned short num;
- REQUIRE(rdata->type == 35);
+ REQUIRE(rdata->type == dns_rdatatype_naptr);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
isc_region_t sr;
unsigned char *regex;
- REQUIRE(type == 35);
+ REQUIRE(type == dns_rdatatype_naptr);
UNUSED(type);
UNUSED(rdclass);
dns_offsets_t offsets;
isc_region_t sr;
- REQUIRE(rdata->type == 35);
+ REQUIRE(rdata->type == dns_rdatatype_naptr);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_NONE);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 35);
+ REQUIRE(rdata1->type == dns_rdatatype_naptr);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_naptr_t *naptr = source;
isc_region_t region;
- REQUIRE(type == 35);
+ REQUIRE(type == dns_rdatatype_naptr);
REQUIRE(source != NULL);
REQUIRE(naptr->common.rdtype == type);
REQUIRE(naptr->common.rdclass == rdclass);
isc_result_t result;
dns_name_t name;
- REQUIRE(rdata->type == 35);
+ REQUIRE(rdata->type == dns_rdatatype_naptr);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_naptr_t *naptr = source;
REQUIRE(source != NULL);
- REQUIRE(naptr->common.rdtype == 35);
+ REQUIRE(naptr->common.rdtype == dns_rdatatype_naptr);
if (naptr->mctx == NULL)
return;
unsigned int i, flagslen;
char *cp;
- REQUIRE(rdata->type == 35);
+ REQUIRE(rdata->type == dns_rdatatype_naptr);
/*
* Order, preference.
isc_result_t result;
dns_name_t name;
- REQUIRE(rdata->type == 35);
+ REQUIRE(rdata->type == dns_rdatatype_naptr);
dns_rdata_toregion(rdata, &r1);
r2 = r1;
static inline isc_boolean_t
checkowner_naptr(ARGS_CHECKOWNER) {
- REQUIRE(type == 35);
+ REQUIRE(type == dns_rdatatype_naptr);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_naptr(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 35);
+ REQUIRE(rdata->type == dns_rdatatype_naptr);
UNUSED(rdata);
UNUSED(owner);
isc_token_t token;
unsigned char locator[NS_LOCATORSZ];
- REQUIRE(type == 104);
+ REQUIRE(type == dns_rdatatype_nid);
UNUSED(type);
UNUSED(rdclass);
char buf[sizeof("xxxx:xxxx:xxxx:xxxx")];
unsigned short num;
- REQUIRE(rdata->type == 104);
+ REQUIRE(rdata->type == dns_rdatatype_nid);
REQUIRE(rdata->length != 0);
UNUSED(tctx);
fromwire_nid(ARGS_FROMWIRE) {
isc_region_t sregion;
- REQUIRE(type == 104);
+ REQUIRE(type == dns_rdatatype_nid);
UNUSED(type);
UNUSED(options);
static inline isc_result_t
towire_nid(ARGS_TOWIRE) {
- REQUIRE(rdata->type == 104);
+ REQUIRE(rdata->type == dns_rdatatype_nid);
REQUIRE(rdata->length == 10);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 104);
+ REQUIRE(rdata1->type == dns_rdatatype_nid);
REQUIRE(rdata1->length == 10);
REQUIRE(rdata2->length == 10);
fromstruct_nid(ARGS_FROMSTRUCT) {
dns_rdata_nid_t *nid = source;
- REQUIRE(type == 104);
+ REQUIRE(type == dns_rdatatype_nid);
REQUIRE(source != NULL);
REQUIRE(nid->common.rdtype == type);
REQUIRE(nid->common.rdclass == rdclass);
isc_region_t region;
dns_rdata_nid_t *nid = target;
- REQUIRE(rdata->type == 104);
+ REQUIRE(rdata->type == dns_rdatatype_nid);
REQUIRE(target != NULL);
REQUIRE(rdata->length == 10);
dns_rdata_nid_t *nid = source;
REQUIRE(source != NULL);
- REQUIRE(nid->common.rdtype == 104);
+ REQUIRE(nid->common.rdtype == dns_rdatatype_nid);
return;
}
static inline isc_result_t
additionaldata_nid(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 104);
+ REQUIRE(rdata->type == dns_rdatatype_nid);
REQUIRE(rdata->length == 10);
UNUSED(rdata);
digest_nid(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 104);
+ REQUIRE(rdata->type == dns_rdatatype_nid);
REQUIRE(rdata->length == 10);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_nid(ARGS_CHECKOWNER) {
- REQUIRE(type == 104);
+ REQUIRE(type == dns_rdatatype_nid);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_nid(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 104);
+ REQUIRE(rdata->type == dns_rdatatype_nid);
REQUIRE(rdata->length == 10);
UNUSED(rdata);
isc_buffer_t buffer;
isc_boolean_t ok;
- REQUIRE(type == 2);
+ REQUIRE(type == dns_rdatatype_ns);
UNUSED(type);
UNUSED(rdclass);
dns_name_t prefix;
isc_boolean_t sub;
- REQUIRE(rdata->type == 2);
+ REQUIRE(rdata->type == dns_rdatatype_ns);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
fromwire_ns(ARGS_FROMWIRE) {
dns_name_t name;
- REQUIRE(type == 2);
+ REQUIRE(type == dns_rdatatype_ns);
UNUSED(type);
UNUSED(rdclass);
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 2);
+ REQUIRE(rdata->type == dns_rdatatype_ns);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_GLOBAL14);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 2);
+ REQUIRE(rdata1->type == dns_rdatatype_ns);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_ns_t *ns = source;
isc_region_t region;
- REQUIRE(type == 2);
+ REQUIRE(type == dns_rdatatype_ns);
REQUIRE(source != NULL);
REQUIRE(ns->common.rdtype == type);
REQUIRE(ns->common.rdclass == rdclass);
dns_rdata_ns_t *ns = target;
dns_name_t name;
- REQUIRE(rdata->type == 2);
+ REQUIRE(rdata->type == dns_rdatatype_ns);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 2);
+ REQUIRE(rdata->type == dns_rdatatype_ns);
dns_name_init(&name, offsets);
dns_rdata_toregion(rdata, ®ion);
isc_region_t r;
dns_name_t name;
- REQUIRE(rdata->type == 2);
+ REQUIRE(rdata->type == dns_rdatatype_ns);
dns_rdata_toregion(rdata, &r);
dns_name_init(&name, NULL);
static inline isc_boolean_t
checkowner_ns(ARGS_CHECKOWNER) {
- REQUIRE(type == 2);
+ REQUIRE(type == dns_rdatatype_ns);
UNUSED(name);
UNUSED(type);
isc_region_t region;
dns_name_t name;
- REQUIRE(rdata->type == 2);
+ REQUIRE(rdata->type == dns_rdatatype_ns);
UNUSED(owner);
unsigned char hashalg;
isc_buffer_t b;
- REQUIRE(type == 50);
+ REQUIRE(type == dns_rdatatype_nsec3);
UNUSED(type);
UNUSED(rdclass);
isc_uint32_t iterations;
isc_boolean_t first;
- REQUIRE(rdata->type == 50);
+ REQUIRE(rdata->type == dns_rdatatype_nsec3);
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, &sr);
isc_boolean_t first = ISC_TRUE;
unsigned int i;
- REQUIRE(type == 50);
+ REQUIRE(type == dns_rdatatype_nsec3);
UNUSED(type);
UNUSED(rdclass);
towire_nsec3(ARGS_TOWIRE) {
isc_region_t sr;
- REQUIRE(rdata->type == 50);
+ REQUIRE(rdata->type == dns_rdatatype_nsec3);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 50);
+ REQUIRE(rdata1->type == dns_rdatatype_nsec3);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
unsigned int i, len, window, lastwindow = 0;
isc_boolean_t first = ISC_TRUE;
- REQUIRE(type == 50);
+ REQUIRE(type == dns_rdatatype_nsec3);
REQUIRE(source != NULL);
REQUIRE(nsec3->common.rdtype == type);
REQUIRE(nsec3->common.rdclass == rdclass);
isc_region_t region;
dns_rdata_nsec3_t *nsec3 = target;
- REQUIRE(rdata->type == 50);
+ REQUIRE(rdata->type == dns_rdatatype_nsec3);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_nsec3_t *nsec3 = source;
REQUIRE(source != NULL);
- REQUIRE(nsec3->common.rdtype == 50);
+ REQUIRE(nsec3->common.rdtype == dns_rdatatype_nsec3);
if (nsec3->mctx == NULL)
return;
static inline isc_result_t
additionaldata_nsec3(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 50);
+ REQUIRE(rdata->type == dns_rdatatype_nsec3);
UNUSED(rdata);
UNUSED(add);
digest_nsec3(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 50);
+ REQUIRE(rdata->type == dns_rdatatype_nsec3);
dns_rdata_toregion(rdata, &r);
return ((digest)(arg, &r));
isc_buffer_t buffer;
dns_label_t label;
- REQUIRE(type == 50);
+ REQUIRE(type == dns_rdatatype_nsec3);
UNUSED(type);
UNUSED(rdclass);
static inline isc_boolean_t
checknames_nsec3(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 50);
+ REQUIRE(rdata->type == dns_rdatatype_nsec3);
UNUSED(rdata);
UNUSED(owner);
unsigned int flags = 0;
unsigned char hashalg;
- REQUIRE(type == 51);
+ REQUIRE(type == dns_rdatatype_nsec3param);
UNUSED(type);
UNUSED(rdclass);
char buf[sizeof("65535 ")];
isc_uint32_t iterations;
- REQUIRE(rdata->type == 51);
+ REQUIRE(rdata->type == dns_rdatatype_nsec3param);
REQUIRE(rdata->length != 0);
UNUSED(tctx);
isc_region_t sr, rr;
unsigned int saltlen;
- REQUIRE(type == 51);
+ REQUIRE(type == dns_rdatatype_nsec3param);
UNUSED(type);
UNUSED(rdclass);
towire_nsec3param(ARGS_TOWIRE) {
isc_region_t sr;
- REQUIRE(rdata->type == 51);
+ REQUIRE(rdata->type == dns_rdatatype_nsec3param);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 51);
+ REQUIRE(rdata1->type == dns_rdatatype_nsec3param);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_nsec3param(ARGS_FROMSTRUCT) {
dns_rdata_nsec3param_t *nsec3param = source;
- REQUIRE(type == 51);
+ REQUIRE(type == dns_rdatatype_nsec3param);
REQUIRE(source != NULL);
REQUIRE(nsec3param->common.rdtype == type);
REQUIRE(nsec3param->common.rdclass == rdclass);
isc_region_t region;
dns_rdata_nsec3param_t *nsec3param = target;
- REQUIRE(rdata->type == 51);
+ REQUIRE(rdata->type == dns_rdatatype_nsec3param);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_nsec3param_t *nsec3param = source;
REQUIRE(source != NULL);
- REQUIRE(nsec3param->common.rdtype == 51);
+ REQUIRE(nsec3param->common.rdtype == dns_rdatatype_nsec3param);
if (nsec3param->mctx == NULL)
return;
static inline isc_result_t
additionaldata_nsec3param(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 51);
+ REQUIRE(rdata->type == dns_rdatatype_nsec3param);
UNUSED(rdata);
UNUSED(add);
digest_nsec3param(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 51);
+ REQUIRE(rdata->type == dns_rdatatype_nsec3param);
dns_rdata_toregion(rdata, &r);
return ((digest)(arg, &r));
static inline isc_boolean_t
checkowner_nsec3param(ARGS_CHECKOWNER) {
- REQUIRE(type == 51);
+ REQUIRE(type == dns_rdatatype_nsec3param);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_nsec3param(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 51);
+ REQUIRE(rdata->type == dns_rdatatype_nsec3param);
UNUSED(rdata);
UNUSED(owner);
int octet;
int window;
- REQUIRE(type == 47);
+ REQUIRE(type == dns_rdatatype_nsec);
UNUSED(type);
UNUSED(rdclass);
dns_name_t name;
unsigned int window, len;
- REQUIRE(rdata->type == 47);
+ REQUIRE(rdata->type == dns_rdatatype_nsec);
REQUIRE(rdata->length != 0);
UNUSED(tctx);
isc_boolean_t first = ISC_TRUE;
unsigned int i;
- REQUIRE(type == 47);
+ REQUIRE(type == dns_rdatatype_nsec);
UNUSED(type);
UNUSED(rdclass);
dns_name_t name;
dns_offsets_t offsets;
- REQUIRE(rdata->type == 47);
+ REQUIRE(rdata->type == dns_rdatatype_nsec);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_NONE);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 47);
+ REQUIRE(rdata1->type == dns_rdatatype_nsec);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
unsigned int i, len, window, lastwindow = 0;
isc_boolean_t first = ISC_TRUE;
- REQUIRE(type == 47);
+ REQUIRE(type == dns_rdatatype_nsec);
REQUIRE(source != NULL);
REQUIRE(nsec->common.rdtype == type);
REQUIRE(nsec->common.rdclass == rdclass);
dns_rdata_nsec_t *nsec = target;
dns_name_t name;
- REQUIRE(rdata->type == 47);
+ REQUIRE(rdata->type == dns_rdatatype_nsec);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_nsec_t *nsec = source;
REQUIRE(source != NULL);
- REQUIRE(nsec->common.rdtype == 47);
+ REQUIRE(nsec->common.rdtype == dns_rdatatype_nsec);
if (nsec->mctx == NULL)
return;
static inline isc_result_t
additionaldata_nsec(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 47);
+ REQUIRE(rdata->type == dns_rdatatype_nsec);
UNUSED(rdata);
UNUSED(add);
digest_nsec(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 47);
+ REQUIRE(rdata->type == dns_rdatatype_nsec);
dns_rdata_toregion(rdata, &r);
return ((digest)(arg, &r));
static inline isc_boolean_t
checkowner_nsec(ARGS_CHECKOWNER) {
- REQUIRE(type == 47);
+ REQUIRE(type == dns_rdatatype_nsec);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_nsec(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 47);
+ REQUIRE(rdata->type == dns_rdatatype_nsec);
UNUSED(rdata);
UNUSED(owner);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 47);
+ REQUIRE(rdata1->type == dns_rdatatype_nsec);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
static inline isc_result_t
fromtext_null(ARGS_FROMTEXT) {
- REQUIRE(type == 10);
+ REQUIRE(type == dns_rdatatype_null);
UNUSED(rdclass);
UNUSED(type);
static inline isc_result_t
totext_null(ARGS_TOTEXT) {
- REQUIRE(rdata->type == 10);
+ REQUIRE(rdata->type == dns_rdatatype_null);
return (unknown_totext(rdata, tctx, target));
}
fromwire_null(ARGS_FROMWIRE) {
isc_region_t sr;
- REQUIRE(type == 10);
+ REQUIRE(type == dns_rdatatype_null);
UNUSED(type);
UNUSED(rdclass);
static inline isc_result_t
towire_null(ARGS_TOWIRE) {
- REQUIRE(rdata->type == 10);
+ REQUIRE(rdata->type == dns_rdatatype_null);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 10);
+ REQUIRE(rdata1->type == dns_rdatatype_null);
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
fromstruct_null(ARGS_FROMSTRUCT) {
dns_rdata_null_t *null = source;
- REQUIRE(type == 10);
+ REQUIRE(type == dns_rdatatype_null);
REQUIRE(source != NULL);
REQUIRE(null->common.rdtype == type);
REQUIRE(null->common.rdclass == rdclass);
dns_rdata_null_t *null = target;
isc_region_t r;
- REQUIRE(rdata->type == 10);
+ REQUIRE(rdata->type == dns_rdatatype_null);
REQUIRE(target != NULL);
null->common.rdclass = rdata->rdclass;
dns_rdata_null_t *null = source;
REQUIRE(source != NULL);
- REQUIRE(null->common.rdtype == 10);
+ REQUIRE(null->common.rdtype == dns_rdatatype_null);
if (null->mctx == NULL)
return;
UNUSED(add);
UNUSED(arg);
- REQUIRE(rdata->type == 10);
+ REQUIRE(rdata->type == dns_rdatatype_null);
return (ISC_R_SUCCESS);
}
digest_null(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 10);
+ REQUIRE(rdata->type == dns_rdatatype_null);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_null(ARGS_CHECKOWNER) {
- REQUIRE(type == 10);
+ REQUIRE(type == dns_rdatatype_null);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_null(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 10);
+ REQUIRE(rdata->type == dns_rdatatype_null);
UNUSED(rdata);
UNUSED(owner);
isc_boolean_t first = ISC_TRUE;
long n;
- REQUIRE(type == 30);
+ REQUIRE(type == dns_rdatatype_nxt);
UNUSED(type);
UNUSED(rdclass);
dns_name_t prefix;
isc_boolean_t sub;
- REQUIRE(rdata->type == 30);
+ REQUIRE(rdata->type == dns_rdatatype_nxt);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
isc_region_t sr;
dns_name_t name;
- REQUIRE(type == 30);
+ REQUIRE(type == dns_rdatatype_nxt);
UNUSED(type);
UNUSED(rdclass);
dns_name_t name;
dns_offsets_t offsets;
- REQUIRE(rdata->type == 30);
+ REQUIRE(rdata->type == dns_rdatatype_nxt);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_NONE);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 30);
+ REQUIRE(rdata1->type == dns_rdatatype_nxt);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_nxt_t *nxt = source;
isc_region_t region;
- REQUIRE(type == 30);
+ REQUIRE(type == dns_rdatatype_nxt);
REQUIRE(source != NULL);
REQUIRE(nxt->common.rdtype == type);
REQUIRE(nxt->common.rdclass == rdclass);
dns_rdata_nxt_t *nxt = target;
dns_name_t name;
- REQUIRE(rdata->type == 30);
+ REQUIRE(rdata->type == dns_rdatatype_nxt);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_nxt_t *nxt = source;
REQUIRE(source != NULL);
- REQUIRE(nxt->common.rdtype == 30);
+ REQUIRE(nxt->common.rdtype == dns_rdatatype_nxt);
if (nxt->mctx == NULL)
return;
static inline isc_result_t
additionaldata_nxt(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 30);
+ REQUIRE(rdata->type == dns_rdatatype_nxt);
UNUSED(rdata);
UNUSED(add);
dns_name_t name;
isc_result_t result;
- REQUIRE(rdata->type == 30);
+ REQUIRE(rdata->type == dns_rdatatype_nxt);
dns_rdata_toregion(rdata, &r);
dns_name_init(&name, NULL);
static inline isc_boolean_t
checkowner_nxt(ARGS_CHECKOWNER) {
- REQUIRE(type == 30);
+ REQUIRE(type == dns_rdatatype_nxt);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_nxt(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 30);
+ REQUIRE(rdata->type == dns_rdatatype_nxt);
UNUSED(rdata);
UNUSED(owner);
static inline isc_result_t
fromtext_openpgpkey(ARGS_FROMTEXT) {
- REQUIRE(type == 61);
+ REQUIRE(type == dns_rdatatype_openpgpkey);
UNUSED(type);
UNUSED(rdclass);
totext_openpgpkey(ARGS_TOTEXT) {
isc_region_t sr;
- REQUIRE(rdata->type == 61);
+ REQUIRE(rdata->type == dns_rdatatype_openpgpkey);
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, &sr);
fromwire_openpgpkey(ARGS_FROMWIRE) {
isc_region_t sr;
- REQUIRE(type == 61);
+ REQUIRE(type == dns_rdatatype_openpgpkey);
UNUSED(type);
UNUSED(rdclass);
towire_openpgpkey(ARGS_TOWIRE) {
isc_region_t sr;
- REQUIRE(rdata->type == 61);
+ REQUIRE(rdata->type == dns_rdatatype_openpgpkey);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 61);
+ REQUIRE(rdata1->type == dns_rdatatype_openpgpkey);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_openpgpkey(ARGS_FROMSTRUCT) {
dns_rdata_openpgpkey_t *sig = source;
- REQUIRE(type == 61);
+ REQUIRE(type == dns_rdatatype_openpgpkey);
REQUIRE(source != NULL);
REQUIRE(sig->common.rdtype == type);
REQUIRE(sig->common.rdclass == rdclass);
isc_region_t sr;
dns_rdata_openpgpkey_t *sig = target;
- REQUIRE(rdata->type == 61);
+ REQUIRE(rdata->type == dns_rdatatype_openpgpkey);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_openpgpkey_t *sig = (dns_rdata_openpgpkey_t *) source;
REQUIRE(source != NULL);
- REQUIRE(sig->common.rdtype == 61);
+ REQUIRE(sig->common.rdtype == dns_rdatatype_openpgpkey);
if (sig->mctx == NULL)
return;
static inline isc_result_t
additionaldata_openpgpkey(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 61);
+ REQUIRE(rdata->type == dns_rdatatype_openpgpkey);
UNUSED(rdata);
UNUSED(add);
digest_openpgpkey(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 61);
+ REQUIRE(rdata->type == dns_rdatatype_openpgpkey);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_openpgpkey(ARGS_CHECKOWNER) {
- REQUIRE(type == 61);
+ REQUIRE(type == dns_rdatatype_openpgpkey);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_openpgpkey(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 61);
+ REQUIRE(rdata->type == dns_rdatatype_openpgpkey);
UNUSED(rdata);
UNUSED(owner);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 61);
+ REQUIRE(rdata1->type == dns_rdatatype_openpgpkey);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
* OPT records do not have a text format.
*/
- REQUIRE(type == 41);
+ REQUIRE(type == dns_rdatatype_opt);
UNUSED(type);
UNUSED(rdclass);
* OPT records do not have a text format.
*/
- REQUIRE(rdata->type == 41);
+ REQUIRE(rdata->type == dns_rdatatype_opt);
dns_rdata_toregion(rdata, &r);
while (r.length > 0) {
isc_uint16_t length;
unsigned int total;
- REQUIRE(type == 41);
+ REQUIRE(type == dns_rdatatype_opt);
UNUSED(type);
UNUSED(rdclass);
static inline isc_result_t
towire_opt(ARGS_TOWIRE) {
- REQUIRE(rdata->type == 41);
+ REQUIRE(rdata->type == dns_rdatatype_opt);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 41);
+ REQUIRE(rdata1->type == dns_rdatatype_opt);
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
isc_region_t region;
isc_uint16_t length;
- REQUIRE(type == 41);
+ REQUIRE(type == dns_rdatatype_opt);
REQUIRE(source != NULL);
REQUIRE(opt->common.rdtype == type);
REQUIRE(opt->common.rdclass == rdclass);
dns_rdata_opt_t *opt = target;
isc_region_t r;
- REQUIRE(rdata->type == 41);
+ REQUIRE(rdata->type == dns_rdatatype_opt);
REQUIRE(target != NULL);
opt->common.rdclass = rdata->rdclass;
dns_rdata_opt_t *opt = source;
REQUIRE(source != NULL);
- REQUIRE(opt->common.rdtype == 41);
+ REQUIRE(opt->common.rdtype == dns_rdatatype_opt);
if (opt->mctx == NULL)
return;
static inline isc_result_t
additionaldata_opt(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 41);
+ REQUIRE(rdata->type == dns_rdatatype_opt);
UNUSED(rdata);
UNUSED(add);
* OPT records are not digested.
*/
- REQUIRE(rdata->type == 41);
+ REQUIRE(rdata->type == dns_rdatatype_opt);
UNUSED(rdata);
UNUSED(digest);
static inline isc_boolean_t
checkowner_opt(ARGS_CHECKOWNER) {
- REQUIRE(type == 41);
+ REQUIRE(type == dns_rdatatype_opt);
UNUSED(type);
UNUSED(rdclass);
static inline isc_boolean_t
checknames_opt(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 41);
+ REQUIRE(rdata->type == dns_rdatatype_opt);
UNUSED(rdata);
UNUSED(owner);
dns_rdata_opt_first(dns_rdata_opt_t *opt) {
REQUIRE(opt != NULL);
- REQUIRE(opt->common.rdtype == 41);
+ REQUIRE(opt->common.rdtype == dns_rdatatype_opt);
REQUIRE(opt->options != NULL || opt->length == 0);
if (opt->length == 0)
isc_uint16_t length;
REQUIRE(opt != NULL);
- REQUIRE(opt->common.rdtype == 41);
+ REQUIRE(opt->common.rdtype == dns_rdatatype_opt);
REQUIRE(opt->options != NULL && opt->length != 0);
REQUIRE(opt->offset < opt->length);
REQUIRE(opt != NULL);
REQUIRE(opcode != NULL);
- REQUIRE(opt->common.rdtype == 41);
+ REQUIRE(opt->common.rdtype == dns_rdatatype_opt);
REQUIRE(opt->options != NULL);
REQUIRE(opt->offset < opt->length);
fromtext_#(ARGS_FROMTEXT) {
isc_token_t token;
- REQUIRE(type == #);
+ REQUIRE(type == dns_rdatatype_proforma.c#);
REQUIRE(rdclass == #);
RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
static inline isc_result_t
totext_#(ARGS_TOTEXT) {
- REQUIRE(rdata->type == #);
+ REQUIRE(rdata->type == dns_rdatatype_proforma.c#);
REQUIRE(rdata->rdclass == #);
REQUIRE(rdata->length != 0); /* XXX */
static inline isc_result_t
fromwire_#(ARGS_FROMWIRE) {
- REQUIRE(type == #);
+ REQUIRE(type == dns_rdatatype_proforma.c#);
REQUIRE(rdclass == #);
/* NONE or GLOBAL14 */
static inline isc_result_t
towire_#(ARGS_TOWIRE) {
- REQUIRE(rdata->type == #);
+ REQUIRE(rdata->type == dns_rdatatype_proforma.c#);
REQUIRE(rdata->rdclass == #);
REQUIRE(rdata->length != 0); /* XXX */
isc_region_t r1;
isc_region_t r2;
- REQUIRE(rdata1->type == rdata2->type);
+ REQUIRE(rdata1->type == dns_rdatatype_proforma.crdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == #);
+ REQUIRE(rdata1->type == dns_rdatatype_proforma.c#);
REQUIRE(rdata1->rdclass == #);
REQUIRE(rdata1->length != 0); /* XXX */
REQUIRE(rdata2->length != 0); /* XXX */
fromstruct_#(ARGS_FROMSTRUCT) {
dns_rdata_#_t *# = source;
- REQUIRE(type == #);
+ REQUIRE(type == dns_rdatatype_proforma.c#);
REQUIRE(rdclass == #);
REQUIRE(source != NULL);
- REQUIRE(#->common.rdtype == type);
+ REQUIRE(#->common.rdtype == dns_rdatatype_proforma.ctype);
REQUIRE(#->common.rdclass == rdclass);
return (ISC_R_NOTIMPLEMENTED);
static inline isc_result_t
tostruct_#(ARGS_TOSTRUCT) {
- REQUIRE(rdata->type == #);
+ REQUIRE(rdata->type == dns_rdatatype_proforma.c#);
REQUIRE(rdata->rdclass == #);
REQUIRE(rdata->length != 0); /* XXX */
dns_rdata_#_t *# = source;
REQUIRE(source != NULL);
- REQUIRE(#->common.rdtype == #);
+ REQUIRE(#->common.rdtype == dns_rdatatype_proforma.c#);
REQUIRE(#->common.rdclass == #);
}
static inline isc_result_t
additionaldata_#(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == #);
+ REQUIRE(rdata->type == dns_rdatatype_proforma.c#);
REQUIRE(rdata->rdclass == #);
(void)add;
digest_#(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == #);
+ REQUIRE(rdata->type == dns_rdatatype_proforma.c#);
REQUIRE(rdata->rdclass == #);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_#(ARGS_CHECKOWNER) {
- REQUIRE(type == #);
+ REQUIRE(type == dns_rdatatype_proforma.c#);
REQUIRE(rdclass == #);
UNUSED(name);
static inline isc_boolean_t
checknames_#(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == #);
+ REQUIRE(rdata->type == dns_rdatatype_proforma.c#);
REQUIRE(rdata->rdclass == #);
UNUSED(rdata);
isc_region_t r1;
isc_region_t r2;
- REQUIRE(rdata1->type == rdata2->type);
+ REQUIRE(rdata1->type == dns_rdatatype_proforma.crdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == #);
+ REQUIRE(rdata1->type == dns_rdatatype_proforma.c#);
REQUIRE(rdata1->rdclass == #);
REQUIRE(rdata1->length != 0); /* XXX */
REQUIRE(rdata2->length != 0); /* XXX */
dns_name_t name;
isc_buffer_t buffer;
- REQUIRE(type == 12);
+ REQUIRE(type == dns_rdatatype_ptr);
UNUSED(type);
UNUSED(rdclass);
dns_name_t prefix;
isc_boolean_t sub;
- REQUIRE(rdata->type == 12);
+ REQUIRE(rdata->type == dns_rdatatype_ptr);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
fromwire_ptr(ARGS_FROMWIRE) {
dns_name_t name;
- REQUIRE(type == 12);
+ REQUIRE(type == dns_rdatatype_ptr);
UNUSED(type);
UNUSED(rdclass);
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 12);
+ REQUIRE(rdata->type == dns_rdatatype_ptr);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_GLOBAL14);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 12);
+ REQUIRE(rdata1->type == dns_rdatatype_ptr);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_ptr_t *ptr = source;
isc_region_t region;
- REQUIRE(type == 12);
+ REQUIRE(type == dns_rdatatype_ptr);
REQUIRE(source != NULL);
REQUIRE(ptr->common.rdtype == type);
REQUIRE(ptr->common.rdclass == rdclass);
dns_rdata_ptr_t *ptr = target;
dns_name_t name;
- REQUIRE(rdata->type == 12);
+ REQUIRE(rdata->type == dns_rdatatype_ptr);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_ptr_t *ptr = source;
REQUIRE(source != NULL);
- REQUIRE(ptr->common.rdtype == 12);
+ REQUIRE(ptr->common.rdtype == dns_rdatatype_ptr);
if (ptr->mctx == NULL)
return;
static inline isc_result_t
additionaldata_ptr(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 12);
+ REQUIRE(rdata->type == dns_rdatatype_ptr);
UNUSED(rdata);
UNUSED(add);
isc_region_t r;
dns_name_t name;
- REQUIRE(rdata->type == 12);
+ REQUIRE(rdata->type == dns_rdatatype_ptr);
dns_rdata_toregion(rdata, &r);
dns_name_init(&name, NULL);
static inline isc_boolean_t
checkowner_ptr(ARGS_CHECKOWNER) {
- REQUIRE(type == 12);
+ REQUIRE(type == dns_rdatatype_ptr);
UNUSED(name);
UNUSED(type);
isc_region_t region;
dns_name_t name;
- REQUIRE(rdata->type == 12);
+ REQUIRE(rdata->type == dns_rdatatype_ptr);
if (rdata->rdclass != dns_rdataclass_in)
return (ISC_TRUE);
int i;
isc_boolean_t ok;
- REQUIRE(type == 17);
+ REQUIRE(type == dns_rdatatype_rp);
UNUSED(type);
UNUSED(rdclass);
dns_name_t prefix;
isc_boolean_t sub;
- REQUIRE(rdata->type == 17);
+ REQUIRE(rdata->type == dns_rdatatype_rp);
REQUIRE(rdata->length != 0);
dns_name_init(&rmail, NULL);
dns_name_t rmail;
dns_name_t email;
- REQUIRE(type == 17);
+ REQUIRE(type == dns_rdatatype_rp);
UNUSED(type);
UNUSED(rdclass);
dns_offsets_t roffsets;
dns_offsets_t eoffsets;
- REQUIRE(rdata->type == 17);
+ REQUIRE(rdata->type == dns_rdatatype_rp);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_NONE);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 17);
+ REQUIRE(rdata1->type == dns_rdatatype_rp);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_rp_t *rp = source;
isc_region_t region;
- REQUIRE(type == 17);
+ REQUIRE(type == dns_rdatatype_rp);
REQUIRE(source != NULL);
REQUIRE(rp->common.rdtype == type);
REQUIRE(rp->common.rdclass == rdclass);
dns_rdata_rp_t *rp = target;
dns_name_t name;
- REQUIRE(rdata->type == 17);
+ REQUIRE(rdata->type == dns_rdatatype_rp);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_rp_t *rp = source;
REQUIRE(source != NULL);
- REQUIRE(rp->common.rdtype == 17);
+ REQUIRE(rp->common.rdtype == dns_rdatatype_rp);
if (rp->mctx == NULL)
return;
static inline isc_result_t
additionaldata_rp(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 17);
+ REQUIRE(rdata->type == dns_rdatatype_rp);
UNUSED(rdata);
UNUSED(add);
isc_region_t r;
dns_name_t name;
- REQUIRE(rdata->type == 17);
+ REQUIRE(rdata->type == dns_rdatatype_rp);
dns_rdata_toregion(rdata, &r);
dns_name_init(&name, NULL);
static inline isc_boolean_t
checkowner_rp(ARGS_CHECKOWNER) {
- REQUIRE(type == 17);
+ REQUIRE(type == dns_rdatatype_rp);
UNUSED(name);
UNUSED(type);
isc_region_t region;
dns_name_t name;
- REQUIRE(rdata->type == 17);
+ REQUIRE(rdata->type == dns_rdatatype_rp);
UNUSED(owner);
isc_buffer_t buffer;
isc_uint32_t time_signed, time_expire;
- REQUIRE(type == 46);
+ REQUIRE(type == dns_rdatatype_rrsig);
UNUSED(type);
UNUSED(rdclass);
unsigned long foot;
dns_name_t name;
- REQUIRE(rdata->type == 46);
+ REQUIRE(rdata->type == dns_rdatatype_rrsig);
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, &sr);
isc_region_t sr;
dns_name_t name;
- REQUIRE(type == 46);
+ REQUIRE(type == dns_rdatatype_rrsig);
UNUSED(type);
UNUSED(rdclass);
dns_name_t name;
dns_offsets_t offsets;
- REQUIRE(rdata->type == 46);
+ REQUIRE(rdata->type == dns_rdatatype_rrsig);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_NONE);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 46);
+ REQUIRE(rdata1->type == dns_rdatatype_rrsig);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_rrsig(ARGS_FROMSTRUCT) {
dns_rdata_rrsig_t *sig = source;
- REQUIRE(type == 46);
+ REQUIRE(type == dns_rdatatype_rrsig);
REQUIRE(source != NULL);
REQUIRE(sig->common.rdtype == type);
REQUIRE(sig->common.rdclass == rdclass);
dns_rdata_rrsig_t *sig = target;
dns_name_t signer;
- REQUIRE(rdata->type == 46);
+ REQUIRE(rdata->type == dns_rdatatype_rrsig);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_rrsig_t *sig = (dns_rdata_rrsig_t *) source;
REQUIRE(source != NULL);
- REQUIRE(sig->common.rdtype == 46);
+ REQUIRE(sig->common.rdtype == dns_rdatatype_rrsig);
if (sig->mctx == NULL)
return;
static inline isc_result_t
additionaldata_rrsig(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 46);
+ REQUIRE(rdata->type == dns_rdatatype_rrsig);
UNUSED(rdata);
UNUSED(add);
static inline isc_result_t
digest_rrsig(ARGS_DIGEST) {
- REQUIRE(rdata->type == 46);
+ REQUIRE(rdata->type == dns_rdatatype_rrsig);
UNUSED(rdata);
UNUSED(digest);
dns_rdatatype_t type;
isc_region_t r;
- REQUIRE(rdata->type == 46);
+ REQUIRE(rdata->type == dns_rdatatype_rrsig);
dns_rdata_toregion(rdata, &r);
type = uint16_fromregion(&r);
static inline isc_boolean_t
checkowner_rrsig(ARGS_CHECKOWNER) {
- REQUIRE(type == 46);
+ REQUIRE(type == dns_rdatatype_rrsig);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_rrsig(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 46);
+ REQUIRE(rdata->type == dns_rdatatype_rrsig);
UNUSED(rdata);
UNUSED(owner);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 46);
+ REQUIRE(rdata1->type == dns_rdatatype_rrsig);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
isc_buffer_t buffer;
isc_boolean_t ok;
- REQUIRE(type == 21);
+ REQUIRE(type == dns_rdatatype_rt);
UNUSED(type);
UNUSED(rdclass);
char buf[sizeof("64000")];
unsigned short num;
- REQUIRE(rdata->type == 21);
+ REQUIRE(rdata->type == dns_rdatatype_rt);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
isc_region_t sregion;
isc_region_t tregion;
- REQUIRE(type == 21);
+ REQUIRE(type == dns_rdatatype_rt);
UNUSED(type);
UNUSED(rdclass);
isc_region_t region;
isc_region_t tr;
- REQUIRE(rdata->type == 21);
+ REQUIRE(rdata->type == dns_rdatatype_rt);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_NONE);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 21);
+ REQUIRE(rdata1->type == dns_rdatatype_rt);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_rt_t *rt = source;
isc_region_t region;
- REQUIRE(type == 21);
+ REQUIRE(type == dns_rdatatype_rt);
REQUIRE(source != NULL);
REQUIRE(rt->common.rdtype == type);
REQUIRE(rt->common.rdclass == rdclass);
dns_rdata_rt_t *rt = target;
dns_name_t name;
- REQUIRE(rdata->type == 21);
+ REQUIRE(rdata->type == dns_rdatatype_rt);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_rt_t *rt = source;
REQUIRE(source != NULL);
- REQUIRE(rt->common.rdtype == 21);
+ REQUIRE(rt->common.rdtype == dns_rdatatype_rt);
if (rt->mctx == NULL)
return;
isc_region_t region;
isc_result_t result;
- REQUIRE(rdata->type == 21);
+ REQUIRE(rdata->type == dns_rdatatype_rt);
dns_name_init(&name, offsets);
dns_rdata_toregion(rdata, ®ion);
isc_result_t result;
dns_name_t name;
- REQUIRE(rdata->type == 21);
+ REQUIRE(rdata->type == dns_rdatatype_rt);
dns_rdata_toregion(rdata, &r1);
r2 = r1;
static inline isc_boolean_t
checkowner_rt(ARGS_CHECKOWNER) {
- REQUIRE(type == 21);
+ REQUIRE(type == dns_rdatatype_rt);
UNUSED(name);
UNUSED(type);
isc_region_t region;
dns_name_t name;
- REQUIRE(rdata->type == 21);
+ REQUIRE(rdata->type == dns_rdatatype_rt);
UNUSED(owner);
isc_buffer_t buffer;
isc_uint32_t time_signed, time_expire;
- REQUIRE(type == 24);
+ REQUIRE(type == dns_rdatatype_sig);
UNUSED(type);
UNUSED(rdclass);
dns_name_t prefix;
isc_boolean_t sub;
- REQUIRE(rdata->type == 24);
+ REQUIRE(rdata->type == dns_rdatatype_sig);
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, &sr);
isc_region_t sr;
dns_name_t name;
- REQUIRE(type == 24);
+ REQUIRE(type == dns_rdatatype_sig);
UNUSED(type);
UNUSED(rdclass);
dns_name_t name;
dns_offsets_t offsets;
- REQUIRE(rdata->type == 24);
+ REQUIRE(rdata->type == dns_rdatatype_sig);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_NONE);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 24);
+ REQUIRE(rdata1->type == dns_rdatatype_sig);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_sig(ARGS_FROMSTRUCT) {
dns_rdata_sig_t *sig = source;
- REQUIRE(type == 24);
+ REQUIRE(type == dns_rdatatype_sig);
REQUIRE(source != NULL);
REQUIRE(sig->common.rdtype == type);
REQUIRE(sig->common.rdclass == rdclass);
dns_rdata_sig_t *sig = target;
dns_name_t signer;
- REQUIRE(rdata->type == 24);
+ REQUIRE(rdata->type == dns_rdatatype_sig);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_sig_t *sig = (dns_rdata_sig_t *) source;
REQUIRE(source != NULL);
- REQUIRE(sig->common.rdtype == 24);
+ REQUIRE(sig->common.rdtype == dns_rdatatype_sig);
if (sig->mctx == NULL)
return;
static inline isc_result_t
additionaldata_sig(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 24);
+ REQUIRE(rdata->type == dns_rdatatype_sig);
UNUSED(rdata);
UNUSED(add);
static inline isc_result_t
digest_sig(ARGS_DIGEST) {
- REQUIRE(rdata->type == 24);
+ REQUIRE(rdata->type == dns_rdatatype_sig);
UNUSED(rdata);
UNUSED(digest);
dns_rdatatype_t type;
isc_region_t r;
- REQUIRE(rdata->type == 24);
+ REQUIRE(rdata->type == dns_rdatatype_sig);
dns_rdata_toregion(rdata, &r);
type = uint16_fromregion(&r);
static inline isc_boolean_t
checkowner_sig(ARGS_CHECKOWNER) {
- REQUIRE(type == 24);
+ REQUIRE(type == dns_rdatatype_sig);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_sig(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 24);
+ REQUIRE(rdata->type == dns_rdatatype_sig);
UNUSED(rdata);
UNUSED(owner);
isc_uint32_t n;
isc_boolean_t ok;
- REQUIRE(type == 6);
+ REQUIRE(type == dns_rdatatype_soa);
UNUSED(type);
UNUSED(rdclass);
isc_boolean_t multiline;
isc_boolean_t comm;
- REQUIRE(rdata->type == 6);
+ REQUIRE(rdata->type == dns_rdatatype_soa);
REQUIRE(rdata->length != 0);
multiline = ISC_TF((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0);
isc_region_t sregion;
isc_region_t tregion;
- REQUIRE(type == 6);
+ REQUIRE(type == dns_rdatatype_soa);
UNUSED(type);
UNUSED(rdclass);
dns_offsets_t moffsets;
dns_offsets_t roffsets;
- REQUIRE(rdata->type == 6);
+ REQUIRE(rdata->type == dns_rdatatype_soa);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_GLOBAL14);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 6);
+ REQUIRE(rdata1->type == dns_rdatatype_soa);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_soa_t *soa = source;
isc_region_t region;
- REQUIRE(type == 6);
+ REQUIRE(type == dns_rdatatype_soa);
REQUIRE(source != NULL);
REQUIRE(soa->common.rdtype == type);
REQUIRE(soa->common.rdclass == rdclass);
dns_name_t name;
isc_result_t result;
- REQUIRE(rdata->type == 6);
+ REQUIRE(rdata->type == dns_rdatatype_soa);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_soa_t *soa = source;
REQUIRE(source != NULL);
- REQUIRE(soa->common.rdtype == 6);
+ REQUIRE(soa->common.rdtype == dns_rdatatype_soa);
if (soa->mctx == NULL)
return;
UNUSED(add);
UNUSED(arg);
- REQUIRE(rdata->type == 6);
+ REQUIRE(rdata->type == dns_rdatatype_soa);
return (ISC_R_SUCCESS);
}
isc_region_t r;
dns_name_t name;
- REQUIRE(rdata->type == 6);
+ REQUIRE(rdata->type == dns_rdatatype_soa);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_soa(ARGS_CHECKOWNER) {
- REQUIRE(type == 6);
+ REQUIRE(type == dns_rdatatype_soa);
UNUSED(name);
UNUSED(type);
isc_region_t region;
dns_name_t name;
- REQUIRE(rdata->type == 6);
+ REQUIRE(rdata->type == dns_rdatatype_soa);
UNUSED(owner);
isc_token_t token;
int strings;
- REQUIRE(type == 99);
+ REQUIRE(type == dns_rdatatype_spf);
UNUSED(type);
UNUSED(rdclass);
UNUSED(tctx);
- REQUIRE(rdata->type == 99);
+ REQUIRE(rdata->type == dns_rdatatype_spf);
dns_rdata_toregion(rdata, ®ion);
fromwire_spf(ARGS_FROMWIRE) {
isc_result_t result;
- REQUIRE(type == 99);
+ REQUIRE(type == dns_rdatatype_spf);
UNUSED(type);
UNUSED(dctx);
towire_spf(ARGS_TOWIRE) {
isc_region_t region;
- REQUIRE(rdata->type == 99);
+ REQUIRE(rdata->type == dns_rdatatype_spf);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 99);
+ REQUIRE(rdata1->type == dns_rdatatype_spf);
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
isc_region_t region;
isc_uint8_t length;
- REQUIRE(type == 99);
+ REQUIRE(type == dns_rdatatype_spf);
REQUIRE(source != NULL);
REQUIRE(txt->common.rdtype == type);
REQUIRE(txt->common.rdclass == rdclass);
dns_rdata_spf_t *txt = target;
isc_region_t r;
- REQUIRE(rdata->type == 99);
+ REQUIRE(rdata->type == dns_rdatatype_spf);
REQUIRE(target != NULL);
txt->common.rdclass = rdata->rdclass;
dns_rdata_spf_t *txt = source;
REQUIRE(source != NULL);
- REQUIRE(txt->common.rdtype == 99);
+ REQUIRE(txt->common.rdtype == dns_rdatatype_spf);
if (txt->mctx == NULL)
return;
static inline isc_result_t
additionaldata_spf(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 99);
+ REQUIRE(rdata->type == dns_rdatatype_spf);
UNUSED(rdata);
UNUSED(add);
digest_spf(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 99);
+ REQUIRE(rdata->type == dns_rdatatype_spf);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_spf(ARGS_CHECKOWNER) {
- REQUIRE(type == 99);
+ REQUIRE(type == dns_rdatatype_spf);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_spf(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 99);
+ REQUIRE(rdata->type == dns_rdatatype_spf);
UNUSED(rdata);
UNUSED(owner);
fromtext_sshfp(ARGS_FROMTEXT) {
isc_token_t token;
- REQUIRE(type == 44);
+ REQUIRE(type == dns_rdatatype_sshfp);
UNUSED(type);
UNUSED(rdclass);
char buf[sizeof("64000 ")];
unsigned int n;
- REQUIRE(rdata->type == 44);
+ REQUIRE(rdata->type == dns_rdatatype_sshfp);
REQUIRE(rdata->length != 0);
UNUSED(tctx);
fromwire_sshfp(ARGS_FROMWIRE) {
isc_region_t sr;
- REQUIRE(type == 44);
+ REQUIRE(type == dns_rdatatype_sshfp);
UNUSED(type);
UNUSED(rdclass);
towire_sshfp(ARGS_TOWIRE) {
isc_region_t sr;
- REQUIRE(rdata->type == 44);
+ REQUIRE(rdata->type == dns_rdatatype_sshfp);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 44);
+ REQUIRE(rdata1->type == dns_rdatatype_sshfp);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_sshfp(ARGS_FROMSTRUCT) {
dns_rdata_sshfp_t *sshfp = source;
- REQUIRE(type == 44);
+ REQUIRE(type == dns_rdatatype_sshfp);
REQUIRE(source != NULL);
REQUIRE(sshfp->common.rdtype == type);
REQUIRE(sshfp->common.rdclass == rdclass);
dns_rdata_sshfp_t *sshfp = target;
isc_region_t region;
- REQUIRE(rdata->type == 44);
+ REQUIRE(rdata->type == dns_rdatatype_sshfp);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_sshfp_t *sshfp = source;
REQUIRE(sshfp != NULL);
- REQUIRE(sshfp->common.rdtype == 44);
+ REQUIRE(sshfp->common.rdtype == dns_rdatatype_sshfp);
if (sshfp->mctx == NULL)
return;
static inline isc_result_t
additionaldata_sshfp(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 44);
+ REQUIRE(rdata->type == dns_rdatatype_sshfp);
UNUSED(rdata);
UNUSED(add);
digest_sshfp(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 44);
+ REQUIRE(rdata->type == dns_rdatatype_sshfp);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_sshfp(ARGS_CHECKOWNER) {
- REQUIRE(type == 44);
+ REQUIRE(type == dns_rdatatype_sshfp);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_sshfp(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 44);
+ REQUIRE(rdata->type == dns_rdatatype_sshfp);
UNUSED(rdata);
UNUSED(owner);
long i;
char *e;
- REQUIRE(type == 249);
+ REQUIRE(type == dns_rdatatype_tkey);
UNUSED(type);
UNUSED(rdclass);
dns_name_t prefix;
isc_boolean_t sub;
- REQUIRE(rdata->type == 249);
+ REQUIRE(rdata->type == dns_rdatatype_tkey);
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, &sr);
unsigned long n;
dns_name_t name;
- REQUIRE(type == 249);
+ REQUIRE(type == dns_rdatatype_tkey);
UNUSED(type);
UNUSED(rdclass);
dns_name_t name;
dns_offsets_t offsets;
- REQUIRE(rdata->type == 249);
+ REQUIRE(rdata->type == dns_rdatatype_tkey);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_NONE);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 249);
+ REQUIRE(rdata1->type == dns_rdatatype_tkey);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_tkey(ARGS_FROMSTRUCT) {
dns_rdata_tkey_t *tkey = source;
- REQUIRE(type == 249);
+ REQUIRE(type == dns_rdatatype_tkey);
REQUIRE(source != NULL);
REQUIRE(tkey->common.rdtype == type);
REQUIRE(tkey->common.rdclass == rdclass);
dns_name_t alg;
isc_region_t sr;
- REQUIRE(rdata->type == 249);
+ REQUIRE(rdata->type == dns_rdatatype_tkey);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
UNUSED(add);
UNUSED(arg);
- REQUIRE(rdata->type == 249);
+ REQUIRE(rdata->type == dns_rdatatype_tkey);
return (ISC_R_SUCCESS);
}
UNUSED(digest);
UNUSED(arg);
- REQUIRE(rdata->type == 249);
+ REQUIRE(rdata->type == dns_rdatatype_tkey);
return (ISC_R_NOTIMPLEMENTED);
}
static inline isc_boolean_t
checkowner_tkey(ARGS_CHECKOWNER) {
- REQUIRE(type == 249);
+ REQUIRE(type == dns_rdatatype_tkey);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_tkey(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 249);
+ REQUIRE(rdata->type == dns_rdatatype_tkey);
UNUSED(rdata);
UNUSED(owner);
fromtext_tlsa(ARGS_FROMTEXT) {
isc_token_t token;
- REQUIRE(type == 52);
+ REQUIRE(type == dns_rdatatype_tlsa);
UNUSED(type);
UNUSED(rdclass);
char buf[sizeof("64000 ")];
unsigned int n;
- REQUIRE(rdata->type == 52);
+ REQUIRE(rdata->type == dns_rdatatype_tlsa);
REQUIRE(rdata->length != 0);
UNUSED(tctx);
fromwire_tlsa(ARGS_FROMWIRE) {
isc_region_t sr;
- REQUIRE(type == 52);
+ REQUIRE(type == dns_rdatatype_tlsa);
UNUSED(type);
UNUSED(rdclass);
towire_tlsa(ARGS_TOWIRE) {
isc_region_t sr;
- REQUIRE(rdata->type == 52);
+ REQUIRE(rdata->type == dns_rdatatype_tlsa);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 52);
+ REQUIRE(rdata1->type == dns_rdatatype_tlsa);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_tlsa(ARGS_FROMSTRUCT) {
dns_rdata_tlsa_t *tlsa = source;
- REQUIRE(type == 52);
+ REQUIRE(type == dns_rdatatype_tlsa);
REQUIRE(source != NULL);
REQUIRE(tlsa->common.rdtype == type);
REQUIRE(tlsa->common.rdclass == rdclass);
dns_rdata_tlsa_t *tlsa = target;
isc_region_t region;
- REQUIRE(rdata->type == 52);
+ REQUIRE(rdata->type == dns_rdatatype_tlsa);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_tlsa_t *tlsa = source;
REQUIRE(tlsa != NULL);
- REQUIRE(tlsa->common.rdtype == 52);
+ REQUIRE(tlsa->common.rdtype == dns_rdatatype_tlsa);
if (tlsa->mctx == NULL)
return;
static inline isc_result_t
additionaldata_tlsa(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 52);
+ REQUIRE(rdata->type == dns_rdatatype_tlsa);
UNUSED(rdata);
UNUSED(add);
digest_tlsa(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 52);
+ REQUIRE(rdata->type == dns_rdatatype_tlsa);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_tlsa(ARGS_CHECKOWNER) {
- REQUIRE(type == 52);
+ REQUIRE(type == dns_rdatatype_tlsa);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_tlsa(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 52);
+ REQUIRE(rdata->type == dns_rdatatype_tlsa);
UNUSED(rdata);
UNUSED(owner);
isc_token_t token;
int strings;
- REQUIRE(type == 16);
+ REQUIRE(type == dns_rdatatype_txt);
UNUSED(type);
UNUSED(rdclass);
UNUSED(tctx);
- REQUIRE(rdata->type == 16);
+ REQUIRE(rdata->type == dns_rdatatype_txt);
dns_rdata_toregion(rdata, ®ion);
fromwire_txt(ARGS_FROMWIRE) {
isc_result_t result;
- REQUIRE(type == 16);
+ REQUIRE(type == dns_rdatatype_txt);
UNUSED(type);
UNUSED(dctx);
towire_txt(ARGS_TOWIRE) {
isc_region_t region;
- REQUIRE(rdata->type == 16);
+ REQUIRE(rdata->type == dns_rdatatype_txt);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 16);
+ REQUIRE(rdata1->type == dns_rdatatype_txt);
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
isc_region_t region;
isc_uint8_t length;
- REQUIRE(type == 16);
+ REQUIRE(type == dns_rdatatype_txt);
REQUIRE(source != NULL);
REQUIRE(txt->common.rdtype == type);
REQUIRE(txt->common.rdclass == rdclass);
dns_rdata_txt_t *txt = target;
isc_region_t r;
- REQUIRE(rdata->type == 16);
+ REQUIRE(rdata->type == dns_rdatatype_txt);
REQUIRE(target != NULL);
txt->common.rdclass = rdata->rdclass;
dns_rdata_txt_t *txt = source;
REQUIRE(source != NULL);
- REQUIRE(txt->common.rdtype == 16);
+ REQUIRE(txt->common.rdtype == dns_rdatatype_txt);
if (txt->mctx == NULL)
return;
static inline isc_result_t
additionaldata_txt(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 16);
+ REQUIRE(rdata->type == dns_rdatatype_txt);
UNUSED(rdata);
UNUSED(add);
digest_txt(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 16);
+ REQUIRE(rdata->type == dns_rdatatype_txt);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_txt(ARGS_CHECKOWNER) {
- REQUIRE(type == 16);
+ REQUIRE(type == dns_rdatatype_txt);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_txt(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 16);
+ REQUIRE(rdata->type == dns_rdatatype_txt);
UNUSED(rdata);
UNUSED(owner);
dns_rdata_txt_first(dns_rdata_txt_t *txt) {
REQUIRE(txt != NULL);
- REQUIRE(txt->common.rdtype == 16);
+ REQUIRE(txt->common.rdtype == dns_rdatatype_txt);
REQUIRE(txt->txt != NULL || txt->txt_len == 0);
if (txt->txt_len == 0)
isc_uint8_t length;
REQUIRE(txt != NULL);
- REQUIRE(txt->common.rdtype == 16);
+ REQUIRE(txt->common.rdtype == dns_rdatatype_txt);
REQUIRE(txt->txt != NULL && txt->txt_len != 0);
INSIST(txt->offset + 1 <= txt->txt_len);
REQUIRE(txt != NULL);
REQUIRE(string != NULL);
- REQUIRE(txt->common.rdtype == 16);
+ REQUIRE(txt->common.rdtype == dns_rdatatype_txt);
REQUIRE(txt->txt != NULL);
REQUIRE(txt->offset < txt->txt_len);
static inline isc_result_t
fromtext_unspec(ARGS_FROMTEXT) {
- REQUIRE(type == 103);
+ REQUIRE(type == dns_rdatatype_unspec);
UNUSED(type);
UNUSED(rdclass);
static inline isc_result_t
totext_unspec(ARGS_TOTEXT) {
- REQUIRE(rdata->type == 103);
+ REQUIRE(rdata->type == dns_rdatatype_unspec);
UNUSED(tctx);
fromwire_unspec(ARGS_FROMWIRE) {
isc_region_t sr;
- REQUIRE(type == 103);
+ REQUIRE(type == dns_rdatatype_unspec);
UNUSED(type);
UNUSED(rdclass);
static inline isc_result_t
towire_unspec(ARGS_TOWIRE) {
- REQUIRE(rdata->type == 103);
+ REQUIRE(rdata->type == dns_rdatatype_unspec);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 103);
+ REQUIRE(rdata1->type == dns_rdatatype_unspec);
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
fromstruct_unspec(ARGS_FROMSTRUCT) {
dns_rdata_unspec_t *unspec = source;
- REQUIRE(type == 103);
+ REQUIRE(type == dns_rdatatype_unspec);
REQUIRE(source != NULL);
REQUIRE(unspec->common.rdtype == type);
REQUIRE(unspec->common.rdclass == rdclass);
dns_rdata_unspec_t *unspec = target;
isc_region_t r;
- REQUIRE(rdata->type == 103);
+ REQUIRE(rdata->type == dns_rdatatype_unspec);
REQUIRE(target != NULL);
unspec->common.rdclass = rdata->rdclass;
dns_rdata_unspec_t *unspec = source;
REQUIRE(source != NULL);
- REQUIRE(unspec->common.rdtype == 103);
+ REQUIRE(unspec->common.rdtype == dns_rdatatype_unspec);
if (unspec->mctx == NULL)
return;
static inline isc_result_t
additionaldata_unspec(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 103);
+ REQUIRE(rdata->type == dns_rdatatype_unspec);
UNUSED(rdata);
UNUSED(add);
digest_unspec(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 103);
+ REQUIRE(rdata->type == dns_rdatatype_unspec);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_unspec(ARGS_CHECKOWNER) {
- REQUIRE(type == 103);
+ REQUIRE(type == dns_rdatatype_unspec);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_unspec(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 103);
+ REQUIRE(rdata->type == dns_rdatatype_unspec);
UNUSED(rdata);
UNUSED(owner);
fromtext_uri(ARGS_FROMTEXT) {
isc_token_t token;
- REQUIRE(type == 256);
+ REQUIRE(type == dns_rdatatype_uri);
UNUSED(type);
UNUSED(rdclass);
UNUSED(tctx);
- REQUIRE(rdata->type == 256);
+ REQUIRE(rdata->type == dns_rdatatype_uri);
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, ®ion);
fromwire_uri(ARGS_FROMWIRE) {
isc_region_t region;
- REQUIRE(type == 256);
+ REQUIRE(type == dns_rdatatype_uri);
UNUSED(type);
UNUSED(rdclass);
towire_uri(ARGS_TOWIRE) {
isc_region_t region;
- REQUIRE(rdata->type == 256);
+ REQUIRE(rdata->type == dns_rdatatype_uri);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 256);
+ REQUIRE(rdata1->type == dns_rdatatype_uri);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_uri(ARGS_FROMSTRUCT) {
dns_rdata_uri_t *uri = source;
- REQUIRE(type == 256);
+ REQUIRE(type == dns_rdatatype_uri);
REQUIRE(source != NULL);
REQUIRE(uri->common.rdtype == type);
REQUIRE(uri->common.rdclass == rdclass);
dns_rdata_uri_t *uri = target;
isc_region_t sr;
- REQUIRE(rdata->type == 256);
+ REQUIRE(rdata->type == dns_rdatatype_uri);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_uri_t *uri = (dns_rdata_uri_t *) source;
REQUIRE(source != NULL);
- REQUIRE(uri->common.rdtype == 256);
+ REQUIRE(uri->common.rdtype == dns_rdatatype_uri);
if (uri->mctx == NULL)
return;
static inline isc_result_t
additionaldata_uri(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 256);
+ REQUIRE(rdata->type == dns_rdatatype_uri);
UNUSED(rdata);
UNUSED(add);
digest_uri(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 256);
+ REQUIRE(rdata->type == dns_rdatatype_uri);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_uri(ARGS_CHECKOWNER) {
- REQUIRE(type == 256);
+ REQUIRE(type == dns_rdatatype_uri);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_uri(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 256);
+ REQUIRE(rdata->type == dns_rdatatype_uri);
UNUSED(rdata);
UNUSED(owner);
isc_token_t token;
unsigned int i;
- REQUIRE(type == 19);
+ REQUIRE(type == dns_rdatatype_x25);
UNUSED(type);
UNUSED(rdclass);
UNUSED(tctx);
- REQUIRE(rdata->type == 19);
+ REQUIRE(rdata->type == dns_rdatatype_x25);
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, ®ion);
fromwire_x25(ARGS_FROMWIRE) {
isc_region_t sr;
- REQUIRE(type == 19);
+ REQUIRE(type == dns_rdatatype_x25);
UNUSED(type);
UNUSED(dctx);
towire_x25(ARGS_TOWIRE) {
UNUSED(cctx);
- REQUIRE(rdata->type == 19);
+ REQUIRE(rdata->type == dns_rdatatype_x25);
REQUIRE(rdata->length != 0);
return (mem_tobuffer(target, rdata->data, rdata->length));
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 19);
+ REQUIRE(rdata1->type == dns_rdatatype_x25);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_x25_t *x25 = source;
isc_uint8_t i;
- REQUIRE(type == 19);
+ REQUIRE(type == dns_rdatatype_x25);
REQUIRE(source != NULL);
REQUIRE(x25->common.rdtype == type);
REQUIRE(x25->common.rdclass == rdclass);
dns_rdata_x25_t *x25 = target;
isc_region_t r;
- REQUIRE(rdata->type == 19);
+ REQUIRE(rdata->type == dns_rdatatype_x25);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
freestruct_x25(ARGS_FREESTRUCT) {
dns_rdata_x25_t *x25 = source;
REQUIRE(source != NULL);
- REQUIRE(x25->common.rdtype == 19);
+ REQUIRE(x25->common.rdtype == dns_rdatatype_x25);
if (x25->mctx == NULL)
return;
static inline isc_result_t
additionaldata_x25(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 19);
+ REQUIRE(rdata->type == dns_rdatatype_x25);
UNUSED(rdata);
UNUSED(add);
digest_x25(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 19);
+ REQUIRE(rdata->type == dns_rdatatype_x25);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_x25(ARGS_CHECKOWNER) {
- REQUIRE(type == 19);
+ REQUIRE(type == dns_rdatatype_x25);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_x25(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 19);
+ REQUIRE(rdata->type == dns_rdatatype_x25);
UNUSED(rdata);
UNUSED(owner);
struct in_addr addr;
isc_region_t region;
- REQUIRE(type == 1);
- REQUIRE(rdclass == 4);
+ REQUIRE(type == dns_rdatatype_a);
+ REQUIRE(rdclass == dns_rdataclass_hs);
UNUSED(type);
UNUSED(origin);
totext_hs_a(ARGS_TOTEXT) {
isc_region_t region;
- REQUIRE(rdata->type == 1);
- REQUIRE(rdata->rdclass == 4);
+ REQUIRE(rdata->type == dns_rdatatype_a);
+ REQUIRE(rdata->rdclass == dns_rdataclass_hs);
REQUIRE(rdata->length == 4);
UNUSED(tctx);
isc_region_t sregion;
isc_region_t tregion;
- REQUIRE(type == 1);
- REQUIRE(rdclass == 4);
+ REQUIRE(type == dns_rdatatype_a);
+ REQUIRE(rdclass == dns_rdataclass_hs);
UNUSED(type);
UNUSED(dctx);
towire_hs_a(ARGS_TOWIRE) {
isc_region_t region;
- REQUIRE(rdata->type == 1);
- REQUIRE(rdata->rdclass == 4);
+ REQUIRE(rdata->type == dns_rdatatype_a);
+ REQUIRE(rdata->rdclass == dns_rdataclass_hs);
REQUIRE(rdata->length == 4);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 1);
- REQUIRE(rdata1->rdclass == 4);
+ REQUIRE(rdata1->type == dns_rdatatype_a);
+ REQUIRE(rdata1->rdclass == dns_rdataclass_hs);
REQUIRE(rdata1->length == 4);
REQUIRE(rdata2->length == 4);
dns_rdata_hs_a_t *a = source;
isc_uint32_t n;
- REQUIRE(type == 1);
- REQUIRE(rdclass == 4);
+ REQUIRE(type == dns_rdatatype_a);
+ REQUIRE(rdclass == dns_rdataclass_hs);
REQUIRE(source != NULL);
REQUIRE(a->common.rdtype == type);
REQUIRE(a->common.rdclass == rdclass);
isc_uint32_t n;
isc_region_t region;
- REQUIRE(rdata->type == 1);
- REQUIRE(rdata->rdclass == 4);
+ REQUIRE(rdata->type == dns_rdatatype_a);
+ REQUIRE(rdata->rdclass == dns_rdataclass_hs);
REQUIRE(rdata->length == 4);
UNUSED(mctx);
static inline isc_result_t
additionaldata_hs_a(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 1);
- REQUIRE(rdata->rdclass == 4);
+ REQUIRE(rdata->type == dns_rdatatype_a);
+ REQUIRE(rdata->rdclass == dns_rdataclass_hs);
UNUSED(rdata);
UNUSED(add);
digest_hs_a(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 1);
- REQUIRE(rdata->rdclass == 4);
+ REQUIRE(rdata->type == dns_rdatatype_a);
+ REQUIRE(rdata->rdclass == dns_rdataclass_hs);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_hs_a(ARGS_CHECKOWNER) {
- REQUIRE(type == 1);
- REQUIRE(rdclass == 4);
+ REQUIRE(type == dns_rdatatype_a);
+ REQUIRE(rdclass == dns_rdataclass_hs);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_hs_a(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 1);
- REQUIRE(rdata->rdclass == 4);
+ REQUIRE(rdata->type == dns_rdatatype_a);
+ REQUIRE(rdata->rdclass == dns_rdataclass_hs);
UNUSED(rdata);
UNUSED(owner);
isc_buffer_t buffer;
isc_boolean_t ok;
- REQUIRE(type == 38);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_a6);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(rdclass);
dns_name_t prefix;
isc_boolean_t sub;
- REQUIRE(rdata->type == 38);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_a6);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, &sr);
unsigned char mask;
dns_name_t name;
- REQUIRE(type == 38);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_a6);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(rdclass);
unsigned char prefixlen;
unsigned char octets;
- REQUIRE(rdata->type == 38);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_a6);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_NONE);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 38);
- REQUIRE(rdata1->rdclass == 1);
+ REQUIRE(rdata1->type == dns_rdatatype_a6);
+ REQUIRE(rdata1->rdclass == dns_rdataclass_in);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
isc_uint8_t first;
isc_uint8_t mask;
- REQUIRE(type == 38);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_a6);
+ REQUIRE(rdclass == dns_rdataclass_in);
REQUIRE(source != NULL);
REQUIRE(a6->common.rdtype == type);
REQUIRE(a6->common.rdclass == rdclass);
dns_name_t name;
isc_region_t r;
- REQUIRE(rdata->type == 38);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_a6);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_in_a6_t *a6 = source;
REQUIRE(source != NULL);
- REQUIRE(a6->common.rdclass == 1);
- REQUIRE(a6->common.rdtype == 38);
+ REQUIRE(a6->common.rdclass == dns_rdataclass_in);
+ REQUIRE(a6->common.rdtype == dns_rdatatype_a6);
if (a6->mctx == NULL)
return;
static inline isc_result_t
additionaldata_in_a6(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 38);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_a6);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(rdata);
UNUSED(add);
isc_result_t result;
dns_name_t name;
- REQUIRE(rdata->type == 38);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_a6);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
dns_rdata_toregion(rdata, &r1);
r2 = r1;
static inline isc_boolean_t
checkowner_in_a6(ARGS_CHECKOWNER) {
- REQUIRE(type == 38);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_a6);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(rdclass);
dns_name_t name;
unsigned int prefixlen;
- REQUIRE(rdata->type == 38);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_a6);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(owner);
struct in_addr addr;
isc_region_t region;
- REQUIRE(type == 1);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_a);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(origin);
totext_in_a(ARGS_TOTEXT) {
isc_region_t region;
- REQUIRE(rdata->type == 1);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_a);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length == 4);
UNUSED(tctx);
isc_region_t sregion;
isc_region_t tregion;
- REQUIRE(type == 1);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_a);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(dctx);
towire_in_a(ARGS_TOWIRE) {
isc_region_t region;
- REQUIRE(rdata->type == 1);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_a);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length == 4);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 1);
- REQUIRE(rdata1->rdclass == 1);
+ REQUIRE(rdata1->type == dns_rdatatype_a);
+ REQUIRE(rdata1->rdclass == dns_rdataclass_in);
REQUIRE(rdata1->length == 4);
REQUIRE(rdata2->length == 4);
dns_rdata_in_a_t *a = source;
isc_uint32_t n;
- REQUIRE(type == 1);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_a);
+ REQUIRE(rdclass == dns_rdataclass_in);
REQUIRE(source != NULL);
REQUIRE(a->common.rdtype == type);
REQUIRE(a->common.rdclass == rdclass);
isc_uint32_t n;
isc_region_t region;
- REQUIRE(rdata->type == 1);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_a);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length == 4);
UNUSED(mctx);
dns_rdata_in_a_t *a = source;
REQUIRE(source != NULL);
- REQUIRE(a->common.rdtype == 1);
- REQUIRE(a->common.rdclass == 1);
+ REQUIRE(a->common.rdtype == dns_rdatatype_a);
+ REQUIRE(a->common.rdclass == dns_rdataclass_in);
UNUSED(a);
}
static inline isc_result_t
additionaldata_in_a(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 1);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_a);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(rdata);
UNUSED(add);
digest_in_a(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 1);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_a);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_in_a(ARGS_CHECKOWNER) {
- REQUIRE(type == 1);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_a);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(rdclass);
static inline isc_boolean_t
checknames_in_a(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 1);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_a);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(rdata);
UNUSED(owner);
unsigned char addr[16];
isc_region_t region;
- REQUIRE(type == 28);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_aaaa);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(origin);
UNUSED(tctx);
- REQUIRE(rdata->type == 28);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_aaaa);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length == 16);
dns_rdata_toregion(rdata, ®ion);
isc_region_t sregion;
isc_region_t tregion;
- REQUIRE(type == 28);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_aaaa);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(dctx);
UNUSED(cctx);
- REQUIRE(rdata->type == 28);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_aaaa);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length == 16);
isc_buffer_availableregion(target, ®ion);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 28);
- REQUIRE(rdata1->rdclass == 1);
+ REQUIRE(rdata1->type == dns_rdatatype_aaaa);
+ REQUIRE(rdata1->rdclass == dns_rdataclass_in);
REQUIRE(rdata1->length == 16);
REQUIRE(rdata2->length == 16);
fromstruct_in_aaaa(ARGS_FROMSTRUCT) {
dns_rdata_in_aaaa_t *aaaa = source;
- REQUIRE(type == 28);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_aaaa);
+ REQUIRE(rdclass == dns_rdataclass_in);
REQUIRE(source != NULL);
REQUIRE(aaaa->common.rdtype == type);
REQUIRE(aaaa->common.rdclass == rdclass);
dns_rdata_in_aaaa_t *aaaa = target;
isc_region_t r;
- REQUIRE(rdata->type == 28);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_aaaa);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(target != NULL);
REQUIRE(rdata->length == 16);
dns_rdata_in_aaaa_t *aaaa = source;
REQUIRE(source != NULL);
- REQUIRE(aaaa->common.rdclass == 1);
- REQUIRE(aaaa->common.rdtype == 28);
+ REQUIRE(aaaa->common.rdclass == dns_rdataclass_in);
+ REQUIRE(aaaa->common.rdtype == dns_rdatatype_aaaa);
UNUSED(aaaa);
}
static inline isc_result_t
additionaldata_in_aaaa(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 28);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_aaaa);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(rdata);
UNUSED(add);
digest_in_aaaa(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 28);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_aaaa);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_in_aaaa(ARGS_CHECKOWNER) {
- REQUIRE(type == 28);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_aaaa);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(rdclass);
static inline isc_boolean_t
checknames_in_aaaa(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 28);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_aaaa);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(rdata);
UNUSED(owner);
char *cp, *ap, *slash;
int n;
- REQUIRE(type == 42);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_apl);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(rdclass);
const char *sep = "";
int n;
- REQUIRE(rdata->type == 42);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_apl);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(tctx);
isc_uint8_t prefix;
isc_uint8_t len;
- REQUIRE(type == 42);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_apl);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(dctx);
towire_in_apl(ARGS_TOWIRE) {
UNUSED(cctx);
- REQUIRE(rdata->type == 42);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_apl);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (mem_tobuffer(target, rdata->data, rdata->length));
}
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 42);
- REQUIRE(rdata1->rdclass == 1);
+ REQUIRE(rdata1->type == dns_rdatatype_apl);
+ REQUIRE(rdata1->rdclass == dns_rdataclass_in);
dns_rdata_toregion(rdata1, &r1);
dns_rdata_toregion(rdata2, &r2);
dns_rdata_in_apl_t *apl = source;
isc_buffer_t b;
- REQUIRE(type == 42);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_apl);
+ REQUIRE(rdclass == dns_rdataclass_in);
REQUIRE(source != NULL);
REQUIRE(apl->common.rdtype == type);
REQUIRE(apl->common.rdclass == rdclass);
dns_rdata_in_apl_t *apl = target;
isc_region_t r;
- REQUIRE(rdata->type == 42);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_apl);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
apl->common.rdclass = rdata->rdclass;
apl->common.rdtype = rdata->type;
dns_rdata_in_apl_t *apl = source;
REQUIRE(source != NULL);
- REQUIRE(apl->common.rdtype == 42);
- REQUIRE(apl->common.rdclass == 1);
+ REQUIRE(apl->common.rdtype == dns_rdatatype_apl);
+ REQUIRE(apl->common.rdclass == dns_rdataclass_in);
if (apl->mctx == NULL)
return;
isc_uint32_t length;
REQUIRE(apl != NULL);
- REQUIRE(apl->common.rdtype == 42);
- REQUIRE(apl->common.rdclass == 1);
+ REQUIRE(apl->common.rdtype == dns_rdatatype_apl);
+ REQUIRE(apl->common.rdclass == dns_rdataclass_in);
REQUIRE(apl->apl != NULL || apl->apl_len == 0);
/*
isc_uint32_t length;
REQUIRE(apl != NULL);
- REQUIRE(apl->common.rdtype == 42);
- REQUIRE(apl->common.rdclass == 1);
+ REQUIRE(apl->common.rdtype == dns_rdatatype_apl);
+ REQUIRE(apl->common.rdclass == dns_rdataclass_in);
REQUIRE(apl->apl != NULL || apl->apl_len == 0);
/*
isc_uint32_t length;
REQUIRE(apl != NULL);
- REQUIRE(apl->common.rdtype == 42);
- REQUIRE(apl->common.rdclass == 1);
+ REQUIRE(apl->common.rdtype == dns_rdatatype_apl);
+ REQUIRE(apl->common.rdclass == dns_rdataclass_in);
REQUIRE(ent != NULL);
REQUIRE(apl->apl != NULL || apl->apl_len == 0);
REQUIRE(apl->offset <= apl->apl_len);
static inline isc_result_t
additionaldata_in_apl(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 42);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_apl);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
(void)add;
(void)arg;
digest_in_apl(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 42);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_apl);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_in_apl(ARGS_CHECKOWNER) {
- REQUIRE(type == 42);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_apl);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_in_apl(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 42);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_apl);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(rdata);
UNUSED(owner);
static inline isc_result_t
fromtext_in_dhcid(ARGS_FROMTEXT) {
- REQUIRE(type == 49);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_dhcid);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(rdclass);
char buf[sizeof(" ; 64000 255 64000")];
size_t n;
- REQUIRE(rdata->type == 49);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_dhcid);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, &sr);
fromwire_in_dhcid(ARGS_FROMWIRE) {
isc_region_t sr;
- REQUIRE(type == 49);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_dhcid);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(rdclass);
towire_in_dhcid(ARGS_TOWIRE) {
isc_region_t sr;
- REQUIRE(rdata->type == 49);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_dhcid);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 49);
- REQUIRE(rdata1->rdclass == 1);
+ REQUIRE(rdata1->type == dns_rdatatype_dhcid);
+ REQUIRE(rdata1->rdclass == dns_rdataclass_in);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_in_dhcid(ARGS_FROMSTRUCT) {
dns_rdata_in_dhcid_t *dhcid = source;
- REQUIRE(type == 49);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_dhcid);
+ REQUIRE(rdclass == dns_rdataclass_in);
REQUIRE(source != NULL);
REQUIRE(dhcid->common.rdtype == type);
REQUIRE(dhcid->common.rdclass == rdclass);
dns_rdata_in_dhcid_t *dhcid = target;
isc_region_t region;
- REQUIRE(rdata->type == 49);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_dhcid);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_in_dhcid_t *dhcid = source;
REQUIRE(dhcid != NULL);
- REQUIRE(dhcid->common.rdtype == 49);
- REQUIRE(dhcid->common.rdclass == 1);
+ REQUIRE(dhcid->common.rdtype == dns_rdatatype_dhcid);
+ REQUIRE(dhcid->common.rdclass == dns_rdataclass_in);
if (dhcid->mctx == NULL)
return;
static inline isc_result_t
additionaldata_in_dhcid(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 49);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_dhcid);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(rdata);
UNUSED(add);
digest_in_dhcid(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 49);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_dhcid);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_in_dhcid(ARGS_CHECKOWNER) {
- REQUIRE(type == 49);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_dhcid);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_in_dhcid(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 49);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_dhcid);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(rdata);
UNUSED(owner);
dns_name_t name;
isc_buffer_t buffer;
- REQUIRE(type == 36);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_kx);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(rdclass);
char buf[sizeof("64000")];
unsigned short num;
- REQUIRE(rdata->type == 36);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_kx);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
dns_name_t name;
isc_region_t sregion;
- REQUIRE(type == 36);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_kx);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(rdclass);
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 36);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_kx);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_NONE);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 36);
- REQUIRE(rdata1->rdclass == 1);
+ REQUIRE(rdata1->type == dns_rdatatype_kx);
+ REQUIRE(rdata1->rdclass == dns_rdataclass_in);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_in_kx_t *kx = source;
isc_region_t region;
- REQUIRE(type == 36);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_kx);
+ REQUIRE(rdclass == dns_rdataclass_in);
REQUIRE(source != NULL);
REQUIRE(kx->common.rdtype == type);
REQUIRE(kx->common.rdclass == rdclass);
dns_rdata_in_kx_t *kx = target;
dns_name_t name;
- REQUIRE(rdata->type == 36);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_kx);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_in_kx_t *kx = source;
REQUIRE(source != NULL);
- REQUIRE(kx->common.rdclass == 1);
- REQUIRE(kx->common.rdtype == 36);
+ REQUIRE(kx->common.rdclass == dns_rdataclass_in);
+ REQUIRE(kx->common.rdtype == dns_rdatatype_kx);
if (kx->mctx == NULL)
return;
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 36);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_kx);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
dns_name_init(&name, offsets);
dns_rdata_toregion(rdata, ®ion);
isc_region_t r1, r2;
dns_name_t name;
- REQUIRE(rdata->type == 36);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_kx);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
dns_rdata_toregion(rdata, &r1);
r2 = r1;
static inline isc_boolean_t
checkowner_in_kx(ARGS_CHECKOWNER) {
- REQUIRE(type == 36);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_kx);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_in_kx(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 36);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_kx);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(rdata);
UNUSED(owner);
dns_name_t name;
isc_buffer_t buffer;
- REQUIRE(type == 23);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_nsap_ptr);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(rdclass);
dns_name_t prefix;
isc_boolean_t sub;
- REQUIRE(rdata->type == 23);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_nsap_ptr);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
fromwire_in_nsap_ptr(ARGS_FROMWIRE) {
dns_name_t name;
- REQUIRE(type == 23);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_nsap_ptr);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(rdclass);
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 23);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_nsap_ptr);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_NONE);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 23);
- REQUIRE(rdata1->rdclass == 1);
+ REQUIRE(rdata1->type == dns_rdatatype_nsap_ptr);
+ REQUIRE(rdata1->rdclass == dns_rdataclass_in);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_in_nsap_ptr_t *nsap_ptr = source;
isc_region_t region;
- REQUIRE(type == 23);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_nsap_ptr);
+ REQUIRE(rdclass == dns_rdataclass_in);
REQUIRE(source != NULL);
REQUIRE(nsap_ptr->common.rdtype == type);
REQUIRE(nsap_ptr->common.rdclass == rdclass);
dns_rdata_in_nsap_ptr_t *nsap_ptr = target;
dns_name_t name;
- REQUIRE(rdata->type == 23);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_nsap_ptr);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_in_nsap_ptr_t *nsap_ptr = source;
REQUIRE(source != NULL);
- REQUIRE(nsap_ptr->common.rdclass == 1);
- REQUIRE(nsap_ptr->common.rdtype == 23);
+ REQUIRE(nsap_ptr->common.rdclass == dns_rdataclass_in);
+ REQUIRE(nsap_ptr->common.rdtype == dns_rdatatype_nsap_ptr);
if (nsap_ptr->mctx == NULL)
return;
static inline isc_result_t
additionaldata_in_nsap_ptr(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 23);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_nsap_ptr);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(rdata);
UNUSED(add);
isc_region_t r;
dns_name_t name;
- REQUIRE(rdata->type == 23);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_nsap_ptr);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
dns_rdata_toregion(rdata, &r);
dns_name_init(&name, NULL);
static inline isc_boolean_t
checkowner_in_nsap_ptr(ARGS_CHECKOWNER) {
- REQUIRE(type == 23);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_nsap_ptr);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_in_nsap_ptr(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 23);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_nsap_ptr);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(rdata);
UNUSED(owner);
int digits = 0;
unsigned char c = 0;
- REQUIRE(type == 22);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_nsap);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(origin);
isc_region_t region;
char buf[sizeof("xx")];
- REQUIRE(rdata->type == 22);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_nsap);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length != 0);
UNUSED(tctx);
fromwire_in_nsap(ARGS_FROMWIRE) {
isc_region_t region;
- REQUIRE(type == 22);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_nsap);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(dctx);
static inline isc_result_t
towire_in_nsap(ARGS_TOWIRE) {
- REQUIRE(rdata->type == 22);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_nsap);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length != 0);
UNUSED(cctx);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 22);
- REQUIRE(rdata1->rdclass == 1);
+ REQUIRE(rdata1->type == dns_rdatatype_nsap);
+ REQUIRE(rdata1->rdclass == dns_rdataclass_in);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
fromstruct_in_nsap(ARGS_FROMSTRUCT) {
dns_rdata_in_nsap_t *nsap = source;
- REQUIRE(type == 22);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_nsap);
+ REQUIRE(rdclass == dns_rdataclass_in);
REQUIRE(source != NULL);
REQUIRE(nsap->common.rdtype == type);
REQUIRE(nsap->common.rdclass == rdclass);
dns_rdata_in_nsap_t *nsap = target;
isc_region_t r;
- REQUIRE(rdata->type == 22);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_nsap);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_in_nsap_t *nsap = source;
REQUIRE(source != NULL);
- REQUIRE(nsap->common.rdclass == 1);
- REQUIRE(nsap->common.rdtype == 22);
+ REQUIRE(nsap->common.rdclass == dns_rdataclass_in);
+ REQUIRE(nsap->common.rdtype == dns_rdatatype_nsap);
if (nsap->mctx == NULL)
return;
static inline isc_result_t
additionaldata_in_nsap(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 22);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_nsap);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(rdata);
UNUSED(add);
digest_in_nsap(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 22);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_nsap);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_in_nsap(ARGS_CHECKOWNER) {
- REQUIRE(type == 22);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_nsap);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_in_nsap(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 22);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_nsap);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(rdata);
UNUSED(owner);
dns_name_t name;
isc_buffer_t buffer;
- REQUIRE(type == 26);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_px);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(rdclass);
char buf[sizeof("64000")];
unsigned short num;
- REQUIRE(rdata->type == 26);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_px);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
dns_name_t name;
isc_region_t sregion;
- REQUIRE(type == 26);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_px);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(rdclass);
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 26);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_px);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_NONE);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 26);
- REQUIRE(rdata1->rdclass == 1);
+ REQUIRE(rdata1->type == dns_rdatatype_px);
+ REQUIRE(rdata1->rdclass == dns_rdataclass_in);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_in_px_t *px = source;
isc_region_t region;
- REQUIRE(type == 26);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_px);
+ REQUIRE(rdclass == dns_rdataclass_in);
REQUIRE(source != NULL);
REQUIRE(px->common.rdtype == type);
REQUIRE(px->common.rdclass == rdclass);
isc_region_t region;
isc_result_t result;
- REQUIRE(rdata->type == 26);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_px);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_in_px_t *px = source;
REQUIRE(source != NULL);
- REQUIRE(px->common.rdclass == 1);
- REQUIRE(px->common.rdtype == 26);
+ REQUIRE(px->common.rdclass == dns_rdataclass_in);
+ REQUIRE(px->common.rdtype == dns_rdatatype_px);
if (px->mctx == NULL)
return;
static inline isc_result_t
additionaldata_in_px(ARGS_ADDLDATA) {
- REQUIRE(rdata->type == 26);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_px);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(rdata);
UNUSED(add);
dns_name_t name;
isc_result_t result;
- REQUIRE(rdata->type == 26);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_px);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
dns_rdata_toregion(rdata, &r1);
r2 = r1;
static inline isc_boolean_t
checkowner_in_px(ARGS_CHECKOWNER) {
- REQUIRE(type == 26);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_px);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(name);
UNUSED(type);
static inline isc_boolean_t
checknames_in_px(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 26);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_px);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(rdata);
UNUSED(owner);
isc_buffer_t buffer;
isc_boolean_t ok;
- REQUIRE(type == 33);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_srv);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(rdclass);
char buf[sizeof("64000")];
unsigned short num;
- REQUIRE(rdata->type == 33);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_srv);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length != 0);
dns_name_init(&name, NULL);
dns_name_t name;
isc_region_t sr;
- REQUIRE(type == 33);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_srv);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(rdclass);
dns_offsets_t offsets;
isc_region_t sr;
- REQUIRE(rdata->type == 33);
+ REQUIRE(rdata->type == dns_rdatatype_srv);
REQUIRE(rdata->length != 0);
dns_compress_setmethods(cctx, DNS_COMPRESS_NONE);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 33);
- REQUIRE(rdata1->rdclass == 1);
+ REQUIRE(rdata1->type == dns_rdatatype_srv);
+ REQUIRE(rdata1->rdclass == dns_rdataclass_in);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_in_srv_t *srv = source;
isc_region_t region;
- REQUIRE(type == 33);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_srv);
+ REQUIRE(rdclass == dns_rdataclass_in);
REQUIRE(source != NULL);
REQUIRE(srv->common.rdtype == type);
REQUIRE(srv->common.rdclass == rdclass);
dns_rdata_in_srv_t *srv = target;
dns_name_t name;
- REQUIRE(rdata->rdclass == 1);
- REQUIRE(rdata->type == 33);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
+ REQUIRE(rdata->type == dns_rdatatype_srv);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dns_rdata_in_srv_t *srv = source;
REQUIRE(source != NULL);
- REQUIRE(srv->common.rdclass == 1);
- REQUIRE(srv->common.rdtype == 33);
+ REQUIRE(srv->common.rdclass == dns_rdataclass_in);
+ REQUIRE(srv->common.rdtype == dns_rdatatype_srv);
if (srv->mctx == NULL)
return;
dns_offsets_t offsets;
isc_region_t region;
- REQUIRE(rdata->type == 33);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_srv);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
dns_name_init(&name, offsets);
dns_rdata_toregion(rdata, ®ion);
isc_region_t r1, r2;
dns_name_t name;
- REQUIRE(rdata->type == 33);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_srv);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
dns_rdata_toregion(rdata, &r1);
r2 = r1;
static inline isc_boolean_t
checkowner_in_srv(ARGS_CHECKOWNER) {
- REQUIRE(type == 33);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_srv);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(name);
UNUSED(type);
isc_region_t region;
dns_name_t name;
- REQUIRE(rdata->type == 33);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_srv);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(owner);
char service[32];
int i;
- REQUIRE(type == 11);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_wks);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(origin);
UNUSED(tctx);
- REQUIRE(rdata->type == 11);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_wks);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length >= 5);
dns_rdata_toregion(rdata, &sr);
isc_region_t sr;
isc_region_t tr;
- REQUIRE(type == 11);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_wks);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(dctx);
UNUSED(cctx);
- REQUIRE(rdata->type == 11);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_wks);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length != 0);
dns_rdata_toregion(rdata, &sr);
REQUIRE(rdata1->type == rdata2->type);
REQUIRE(rdata1->rdclass == rdata2->rdclass);
- REQUIRE(rdata1->type == 11);
- REQUIRE(rdata1->rdclass == 1);
+ REQUIRE(rdata1->type == dns_rdatatype_wks);
+ REQUIRE(rdata1->rdclass == dns_rdataclass_in);
REQUIRE(rdata1->length != 0);
REQUIRE(rdata2->length != 0);
dns_rdata_in_wks_t *wks = source;
isc_uint32_t a;
- REQUIRE(type == 11);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_wks);
+ REQUIRE(rdclass == dns_rdataclass_in);
REQUIRE(source != NULL);
REQUIRE(wks->common.rdtype == type);
REQUIRE(wks->common.rdclass == rdclass);
isc_uint32_t n;
isc_region_t region;
- REQUIRE(rdata->type == 11);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_wks);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
REQUIRE(rdata->length != 0);
wks->common.rdclass = rdata->rdclass;
dns_rdata_in_wks_t *wks = source;
REQUIRE(source != NULL);
- REQUIRE(wks->common.rdtype == 11);
- REQUIRE(wks->common.rdclass == 1);
+ REQUIRE(wks->common.rdtype == dns_rdatatype_wks);
+ REQUIRE(wks->common.rdclass == dns_rdataclass_in);
if (wks->mctx == NULL)
return;
UNUSED(add);
UNUSED(arg);
- REQUIRE(rdata->type == 11);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_wks);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
return (ISC_R_SUCCESS);
}
digest_in_wks(ARGS_DIGEST) {
isc_region_t r;
- REQUIRE(rdata->type == 11);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_wks);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
dns_rdata_toregion(rdata, &r);
static inline isc_boolean_t
checkowner_in_wks(ARGS_CHECKOWNER) {
- REQUIRE(type == 11);
- REQUIRE(rdclass == 1);
+ REQUIRE(type == dns_rdatatype_wks);
+ REQUIRE(rdclass == dns_rdataclass_in);
UNUSED(type);
UNUSED(rdclass);
static inline isc_boolean_t
checknames_in_wks(ARGS_CHECKNAMES) {
- REQUIRE(rdata->type == 11);
- REQUIRE(rdata->rdclass == 1);
+ REQUIRE(rdata->type == dns_rdatatype_wks);
+ REQUIRE(rdata->rdclass == dns_rdataclass_in);
UNUSED(rdata);
UNUSED(owner);
projects / thirdparty / bind9.git / commitdiff
