static inline isc_result_t fromstruct_uri(ARGS_FROMSTRUCT) { dns_rdata_uri_t *uri = source; isc_region_t region; isc_uint8_t len; REQUIRE(type == 256); REQUIRE(source != NULL); REQUIRE(uri->common.rdtype == type); REQUIRE(uri->common.rdclass == rdclass); REQUIRE(uri->target != NULL && uri->tgt_len != 0); UNUSED(type); UNUSED(rdclass); /* * Priority */ RETERR(uint16_tobuffer(uri->priority, target)); /* * Weight */ RETERR(uint16_tobuffer(uri->weight, target)); /* * Target URI */ len = 255U; region.base = uri->target; region.length = uri->tgt_len; while (region.length > 0) { REQUIRE(len == 255U); len = uint8_fromregion(®ion); isc_region_consume(®ion, 1); if (region.length < len) return (ISC_R_UNEXPECTEDEND); isc_region_consume(®ion, len); } return (mem_tobuffer(target, uri->target, uri->tgt_len)); }
static inline int casecompare_hip(ARGS_COMPARE) { isc_region_t r1; isc_region_t r2; dns_name_t name1; dns_name_t name2; int order; isc_uint8_t hit_len; isc_uint16_t key_len; REQUIRE(rdata1->type == rdata2->type); REQUIRE(rdata1->rdclass == rdata2->rdclass); REQUIRE(rdata1->type == 55); REQUIRE(rdata1->length != 0); REQUIRE(rdata2->length != 0); dns_rdata_toregion(rdata1, &r1); dns_rdata_toregion(rdata2, &r2); INSIST(r1.length > 4); INSIST(r2.length > 4); r1.length = 4; r2.length = 4; order = isc_region_compare(&r1, &r2); if (order != 0) return (order); hit_len = uint8_fromregion(&r1); isc_region_consume(&r1, 2); /* hit length + algorithm */ key_len = uint16_fromregion(&r1); dns_rdata_toregion(rdata1, &r1); dns_rdata_toregion(rdata2, &r2); isc_region_consume(&r1, 4); isc_region_consume(&r2, 4); INSIST(r1.length >= (unsigned) (hit_len + key_len)); INSIST(r2.length >= (unsigned) (hit_len + key_len)); order = isc_region_compare(&r1, &r2); if (order != 0) return (order); isc_region_consume(&r1, hit_len + key_len); isc_region_consume(&r2, hit_len + key_len); dns_name_init(&name1, NULL); dns_name_init(&name2, NULL); while (r1.length != 0 && r2.length != 0) { dns_name_fromregion(&name1, &r1); dns_name_fromregion(&name2, &r2); order = dns_name_rdatacompare(&name1, &name2); if (order != 0) return (order); isc_region_consume(&r1, name_length(&name1)); isc_region_consume(&r2, name_length(&name2)); } return (isc_region_compare(&r1, &r2)); }
static inline isc_result_t tostruct_uri(ARGS_TOSTRUCT) { dns_rdata_uri_t *uri = target; isc_region_t sr; REQUIRE(rdata->type == 256); REQUIRE(target != NULL); REQUIRE(rdata->length != 0); uri->common.rdclass = rdata->rdclass; uri->common.rdtype = rdata->type; ISC_LINK_INIT(&uri->common, link); dns_rdata_toregion(rdata, &sr); /* * Priority */ if (sr.length < 2) return (ISC_R_UNEXPECTEDEND); uri->priority = uint16_fromregion(&sr); isc_region_consume(&sr, 2); /* * Weight */ if (sr.length < 2) return (ISC_R_UNEXPECTEDEND); uri->weight = uint16_fromregion(&sr); isc_region_consume(&sr, 2); /* * Target URI */ uri->tgt_len = sr.length; uri->target = mem_maybedup(mctx, sr.base, sr.length); if (uri->target == NULL) return (ISC_R_NOMEMORY); uri->mctx = mctx; return (ISC_R_SUCCESS); }
static inline isc_result_t tostruct_key(ARGS_TOSTRUCT) { dns_rdata_key_t *key = target; isc_region_t sr; REQUIRE(rdata->type == 25); REQUIRE(target != NULL); REQUIRE(rdata->length != 0); key->common.rdclass = rdata->rdclass; key->common.rdtype = rdata->type; ISC_LINK_INIT(&key->common, link); dns_rdata_toregion(rdata, &sr); /* Flags */ if (sr.length < 2) return (ISC_R_UNEXPECTEDEND); key->flags = uint16_fromregion(&sr); isc_region_consume(&sr, 2); /* Protocol */ if (sr.length < 1) return (ISC_R_UNEXPECTEDEND); key->protocol = uint8_fromregion(&sr); isc_region_consume(&sr, 1); /* Algorithm */ if (sr.length < 1) return (ISC_R_UNEXPECTEDEND); key->algorithm = uint8_fromregion(&sr); isc_region_consume(&sr, 1); /* Data */ key->datalen = sr.length; key->data = mem_maybedup(mctx, sr.base, key->datalen); if (key->data == NULL) return (ISC_R_NOMEMORY); key->mctx = mctx; return (ISC_R_SUCCESS); }
static inline isc_result_t totext_in_px(ARGS_TOTEXT) { isc_region_t region; dns_name_t name; dns_name_t prefix; isc_boolean_t sub; char buf[sizeof("64000")]; unsigned short num; REQUIRE(rdata->type == dns_rdatatype_px); REQUIRE(rdata->rdclass == dns_rdataclass_in); REQUIRE(rdata->length != 0); dns_name_init(&name, NULL); dns_name_init(&prefix, NULL); /* * Preference. */ dns_rdata_toregion(rdata, ®ion); num = uint16_fromregion(®ion); isc_region_consume(®ion, 2); sprintf(buf, "%u", num); RETERR(str_totext(buf, target)); RETERR(str_totext(" ", target)); /* * MAP822. */ dns_name_fromregion(&name, ®ion); sub = name_prefix(&name, tctx->origin, &prefix); isc_region_consume(®ion, name_length(&name)); RETERR(dns_name_totext(&prefix, sub, target)); RETERR(str_totext(" ", target)); /* * MAPX400. */ dns_name_fromregion(&name, ®ion); sub = name_prefix(&name, tctx->origin, &prefix); return(dns_name_totext(&prefix, sub, target)); }
static inline int compare_sig(ARGS_COMPARE) { isc_region_t r1; isc_region_t r2; dns_name_t name1; dns_name_t name2; int order; REQUIRE(rdata1->type == rdata2->type); REQUIRE(rdata1->rdclass == rdata2->rdclass); REQUIRE(rdata1->type == 24); REQUIRE(rdata1->length != 0); REQUIRE(rdata2->length != 0); dns_rdata_toregion(rdata1, &r1); dns_rdata_toregion(rdata2, &r2); INSIST(r1.length > 18); INSIST(r2.length > 18); r1.length = 18; r2.length = 18; order = isc_region_compare(&r1, &r2); if (order != 0) return (order); dns_name_init(&name1, NULL); dns_name_init(&name2, NULL); dns_rdata_toregion(rdata1, &r1); dns_rdata_toregion(rdata2, &r2); isc_region_consume(&r1, 18); isc_region_consume(&r2, 18); dns_name_fromregion(&name1, &r1); dns_name_fromregion(&name2, &r2); order = dns_name_rdatacompare(&name1, &name2); if (order != 0) return (order); isc_region_consume(&r1, name_length(&name1)); isc_region_consume(&r2, name_length(&name2)); return (isc_region_compare(&r1, &r2)); }
static inline isc_result_t towire_naptr(ARGS_TOWIRE) { dns_name_t name; dns_offsets_t offsets; isc_region_t sr; REQUIRE(rdata->type == dns_rdatatype_naptr); REQUIRE(rdata->length != 0); dns_compress_setmethods(cctx, DNS_COMPRESS_NONE); /* * Order, preference. */ dns_rdata_toregion(rdata, &sr); RETERR(mem_tobuffer(target, sr.base, 4)); isc_region_consume(&sr, 4); /* * Flags. */ RETERR(mem_tobuffer(target, sr.base, sr.base[0] + 1)); isc_region_consume(&sr, sr.base[0] + 1); /* * Service. */ RETERR(mem_tobuffer(target, sr.base, sr.base[0] + 1)); isc_region_consume(&sr, sr.base[0] + 1); /* * Regexp. */ RETERR(mem_tobuffer(target, sr.base, sr.base[0] + 1)); isc_region_consume(&sr, sr.base[0] + 1); /* * Replacement. */ dns_name_init(&name, offsets); dns_name_fromregion(&name, &sr); return (dns_name_towire(&name, cctx, target)); }
static inline isc_result_t tostruct_isdn(ARGS_TOSTRUCT) { dns_rdata_isdn_t *isdn = target; isc_region_t r; REQUIRE(rdata->type == dns_rdatatype_isdn); REQUIRE(target != NULL); REQUIRE(rdata->length != 0); isdn->common.rdclass = rdata->rdclass; isdn->common.rdtype = rdata->type; ISC_LINK_INIT(&isdn->common, link); dns_rdata_toregion(rdata, &r); isdn->isdn_len = uint8_fromregion(&r); isc_region_consume(&r, 1); isdn->isdn = mem_maybedup(mctx, r.base, isdn->isdn_len); if (isdn->isdn == NULL) return (ISC_R_NOMEMORY); isc_region_consume(&r, isdn->isdn_len); if (r.length == 0) { isdn->subaddress_len = 0; isdn->subaddress = NULL; } else { isdn->subaddress_len = uint8_fromregion(&r); isc_region_consume(&r, 1); isdn->subaddress = mem_maybedup(mctx, r.base, isdn->subaddress_len); if (isdn->subaddress == NULL) goto cleanup; } isdn->mctx = mctx; return (ISC_R_SUCCESS); cleanup: if (mctx != NULL && isdn->isdn != NULL) isc_mem_free(mctx, isdn->isdn); return (ISC_R_NOMEMORY); }
static inline isc_result_t totext_opt(ARGS_TOTEXT) { isc_region_t r; isc_region_t or; isc_uint16_t option; isc_uint16_t length; char buf[sizeof("64000 64000")]; /* * OPT records do not have a text format. */ REQUIRE(rdata->type == 41); dns_rdata_toregion(rdata, &r); while (r.length > 0) { option = uint16_fromregion(&r); isc_region_consume(&r, 2); length = uint16_fromregion(&r); isc_region_consume(&r, 2); sprintf(buf, "%u %u", option, length); RETERR(str_totext(buf, target)); INSIST(r.length >= length); if (length > 0) { if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) RETERR(str_totext(" (", target)); RETERR(str_totext(tctx->linebreak, target)); or = r; or.length = length; RETERR(isc_base64_totext(&or, tctx->width - 2, tctx->linebreak, target)); isc_region_consume(&r, length); if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) RETERR(str_totext(" )", target)); } if (r.length > 0) RETERR(str_totext(" ", target)); } return (ISC_R_SUCCESS); }
static inline isc_result_t digest_soa(ARGS_DIGEST) { isc_region_t r; dns_name_t name; REQUIRE(rdata->type == 6); dns_rdata_toregion(rdata, &r); dns_name_init(&name, NULL); dns_name_fromregion(&name, &r); RETERR(dns_name_digest(&name, digest, arg)); isc_region_consume(&r, name_length(&name)); dns_name_init(&name, NULL); dns_name_fromregion(&name, &r); RETERR(dns_name_digest(&name, digest, arg)); isc_region_consume(&r, name_length(&name)); return ((digest)(arg, &r)); }
static inline isc_result_t fromwire_nsec3(ARGS_FROMWIRE) { isc_region_t sr, rr; unsigned int saltlen, hashlen; REQUIRE(type == dns_rdatatype_nsec3); UNUSED(type); UNUSED(rdclass); UNUSED(options); UNUSED(dctx); isc_buffer_activeregion(source, &sr); rr = sr; /* hash(1), flags(1), iteration(2), saltlen(1) */ if (sr.length < 5U) RETERR(DNS_R_FORMERR); saltlen = sr.base[4]; isc_region_consume(&sr, 5); if (sr.length < saltlen) RETERR(DNS_R_FORMERR); isc_region_consume(&sr, saltlen); if (sr.length < 1U) RETERR(DNS_R_FORMERR); hashlen = sr.base[0]; isc_region_consume(&sr, 1); if (sr.length < hashlen) RETERR(DNS_R_FORMERR); isc_region_consume(&sr, hashlen); RETERR(typemap_test(&sr, ISC_TRUE)); RETERR(mem_tobuffer(target, rr.base, rr.length)); isc_buffer_forward(source, rr.length); return (ISC_R_SUCCESS); }
static inline isc_result_t totext_sshfp(ARGS_TOTEXT) { isc_region_t sr; char buf[sizeof("64000 ")]; unsigned int n; REQUIRE(rdata->type == 44); REQUIRE(rdata->length != 0); UNUSED(tctx); dns_rdata_toregion(rdata, &sr); /* * Algorithm. */ n = uint8_fromregion(&sr); isc_region_consume(&sr, 1); sprintf(buf, "%u ", n); RETERR(str_totext(buf, target)); /* * Digest type. */ n = uint8_fromregion(&sr); isc_region_consume(&sr, 1); sprintf(buf, "%u", n); RETERR(str_totext(buf, target)); /* * Digest. */ if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) RETERR(str_totext(" (", target)); RETERR(str_totext(tctx->linebreak, target)); RETERR(isc_hex_totext(&sr, tctx->width - 2, tctx->linebreak, target)); if ((tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) RETERR(str_totext(" )", target)); return (ISC_R_SUCCESS); }
static inline isc_result_t tostruct_in_px(ARGS_TOSTRUCT) { dns_rdata_in_px_t *px = target; dns_name_t name; isc_region_t region; isc_result_t result; REQUIRE(rdata->type == dns_rdatatype_px); REQUIRE(rdata->rdclass == dns_rdataclass_in); REQUIRE(target != NULL); REQUIRE(rdata->length != 0); px->common.rdclass = rdata->rdclass; px->common.rdtype = rdata->type; ISC_LINK_INIT(&px->common, link); dns_name_init(&name, NULL); dns_rdata_toregion(rdata, ®ion); px->preference = uint16_fromregion(®ion); isc_region_consume(®ion, 2); dns_name_fromregion(&name, ®ion); dns_name_init(&px->map822, NULL); RETERR(name_duporclone(&name, mctx, &px->map822)); isc_region_consume(®ion, name_length(&px->map822)); dns_name_init(&px->mapx400, NULL); result = name_duporclone(&name, mctx, &px->mapx400); if (result != ISC_R_SUCCESS) goto cleanup; px->mctx = mctx; return (result); cleanup: dns_name_free(&px->map822, mctx); return (ISC_R_NOMEMORY); }
static inline int compare_minfo(ARGS_COMPARE) { isc_region_t region1; isc_region_t region2; dns_name_t name1; dns_name_t name2; int order; REQUIRE(rdata1->type == rdata2->type); REQUIRE(rdata1->rdclass == rdata2->rdclass); REQUIRE(rdata1->type == 14); REQUIRE(rdata1->length != 0); REQUIRE(rdata2->length != 0); dns_name_init(&name1, NULL); dns_name_init(&name2, NULL); dns_rdata_toregion(rdata1, ®ion1); dns_rdata_toregion(rdata2, ®ion2); dns_name_fromregion(&name1, ®ion1); dns_name_fromregion(&name2, ®ion2); order = dns_name_rdatacompare(&name1, &name2); if (order != 0) return (order); isc_region_consume(®ion1, name_length(&name1)); isc_region_consume(®ion2, name_length(&name2)); dns_name_init(&name1, NULL); dns_name_init(&name2, NULL); dns_name_fromregion(&name1, ®ion1); dns_name_fromregion(&name2, ®ion2); order = dns_name_rdatacompare(&name1, &name2); return (order); }
static inline int compare_ch_a (ARGS_COMPARE) { dns_name_t name1; dns_name_t name2; isc_region_t region1; isc_region_t region2; int order; REQUIRE (rdata1->type == rdata2->type); REQUIRE (rdata1->rdclass == rdata2->rdclass); REQUIRE (rdata1->type == 1); REQUIRE (rdata1->rdclass == dns_rdataclass_ch); REQUIRE (rdata1->length != 0); REQUIRE (rdata2->length != 0); dns_name_init (&name1, NULL); dns_name_init (&name2, NULL); dns_rdata_toregion (rdata1, ®ion1); dns_rdata_toregion (rdata2, ®ion2); dns_name_fromregion (&name1, ®ion1); dns_name_fromregion (&name2, ®ion2); isc_region_consume (®ion1, name_length (&name1)); isc_region_consume (®ion2, name_length (&name2)); order = dns_name_rdatacompare (&name1, &name2); if (order != 0) return (order); order = memcmp (rdata1->data, rdata2->data, 2); if (order != 0) order = (order < 0) ? -1 : 1; return (order); }
static inline int compare_in_srv(ARGS_COMPARE) { dns_name_t name1; dns_name_t name2; isc_region_t region1; isc_region_t region2; int order; REQUIRE(rdata1->type == rdata2->type); REQUIRE(rdata1->rdclass == rdata2->rdclass); REQUIRE(rdata1->type == 33); REQUIRE(rdata1->rdclass == 1); REQUIRE(rdata1->length != 0); REQUIRE(rdata2->length != 0); /* * Priority, weight, port. */ order = memcmp(rdata1->data, rdata2->data, 6); if (order != 0) return (order < 0 ? -1 : 1); /* * Target. */ dns_name_init(&name1, NULL); dns_name_init(&name2, NULL); dns_rdata_toregion(rdata1, ®ion1); dns_rdata_toregion(rdata2, ®ion2); isc_region_consume(®ion1, 6); isc_region_consume(®ion2, 6); dns_name_fromregion(&name1, ®ion1); dns_name_fromregion(&name2, ®ion2); return (dns_name_rdatacompare(&name1, &name2)); }
isc_result_t isc_base64_totext(isc_region_t *source, int wordlength, const char *wordbreak, isc_buffer_t *target) { char buf[5]; unsigned int loops = 0; if (wordlength < 4) wordlength = 4; memset(buf, 0, sizeof(buf)); while (source->length > 2) { buf[0] = base64[(source->base[0]>>2)&0x3f]; buf[1] = base64[((source->base[0]<<4)&0x30)| ((source->base[1]>>4)&0x0f)]; buf[2] = base64[((source->base[1]<<2)&0x3c)| ((source->base[2]>>6)&0x03)]; buf[3] = base64[source->base[2]&0x3f]; RETERR(str_totext(buf, target)); isc_region_consume(source, 3); loops++; if (source->length != 0 && (int)((loops + 1) * 4) >= wordlength) { loops = 0; RETERR(str_totext(wordbreak, target)); } } if (source->length == 2) { buf[0] = base64[(source->base[0]>>2)&0x3f]; buf[1] = base64[((source->base[0]<<4)&0x30)| ((source->base[1]>>4)&0x0f)]; buf[2] = base64[((source->base[1]<<2)&0x3c)]; buf[3] = '='; RETERR(str_totext(buf, target)); isc_region_consume(source, 2); } else if (source->length == 1) {
static inline int casecompare_ipseckey(ARGS_COMPARE) { isc_region_t region1; isc_region_t region2; dns_name_t name1; dns_name_t name2; int order; REQUIRE(rdata1->type == rdata2->type); REQUIRE(rdata1->rdclass == rdata2->rdclass); REQUIRE(rdata1->type == 45); REQUIRE(rdata1->length >= 3); REQUIRE(rdata2->length >= 3); dns_rdata_toregion(rdata1, ®ion1); dns_rdata_toregion(rdata2, ®ion2); if (memcmp(region1.base, region2.base, 3) != 0 || region1.base[1] != 3) return (isc_region_compare(®ion1, ®ion2)); dns_name_init(&name1, NULL); dns_name_init(&name2, NULL); isc_region_consume(®ion1, 3); isc_region_consume(®ion2, 3); dns_name_fromregion(&name1, ®ion1); dns_name_fromregion(&name2, ®ion2); order = dns_name_rdatacompare(&name1, &name2); if (order != 0) return (order); isc_region_consume(®ion1, name_length(&name1)); isc_region_consume(®ion2, name_length(&name2)); return (isc_region_compare(®ion1, ®ion2)); }
static inline isc_result_t fromwire_hip(ARGS_FROMWIRE) { isc_region_t region, rr; dns_name_t name; isc_uint8_t hit_len; isc_uint16_t key_len; REQUIRE(type == dns_rdatatype_hip); UNUSED(type); UNUSED(rdclass); isc_buffer_activeregion(source, ®ion); if (region.length < 4U) RETERR(DNS_R_FORMERR); rr = region; hit_len = uint8_fromregion(®ion); if (hit_len == 0) RETERR(DNS_R_FORMERR); isc_region_consume(®ion, 2); /* hit length + algorithm */ key_len = uint16_fromregion(®ion); if (key_len == 0) RETERR(DNS_R_FORMERR); isc_region_consume(®ion, 2); if (region.length < (unsigned) (hit_len + key_len)) RETERR(DNS_R_FORMERR); RETERR(mem_tobuffer(target, rr.base, 4 + hit_len + key_len)); isc_buffer_forward(source, 4 + hit_len + key_len); dns_decompress_setmethods(dctx, DNS_COMPRESS_NONE); while (isc_buffer_activelength(source) > 0) { dns_name_init(&name, NULL); RETERR(dns_name_fromwire(&name, source, dctx, options, target)); } return (ISC_R_SUCCESS); }
isc_result_t dns_rdata_opt_current(dns_rdata_opt_t *opt, dns_rdata_opt_opcode_t *opcode) { isc_region_t r; REQUIRE(opt != NULL); REQUIRE(opcode != NULL); REQUIRE(opt->common.rdtype == 41); REQUIRE(opt->options != NULL); REQUIRE(opt->offset < opt->length); INSIST(opt->offset + 4 <= opt->length); r.base = opt->options + opt->offset; r.length = opt->length - opt->offset; opcode->opcode = uint16_fromregion(&r); isc_region_consume(&r, 2); opcode->length = uint16_fromregion(&r); isc_region_consume(&r, 2); opcode->data = r.base; INSIST(opt->offset + 4 + opcode->length <= opt->length); return (ISC_R_SUCCESS); }
static isc_result_t openssldsa_todns(const dst_key_t *key, isc_buffer_t *data) { DSA *dsa; isc_region_t r; int dnslen; unsigned int t, p_bytes; REQUIRE(key->keydata.dsa != NULL); dsa = key->keydata.dsa; isc_buffer_availableregion(data, &r); t = (BN_num_bytes(dsa->p) - 64) / 8; if (t > 8) return (DST_R_INVALIDPUBLICKEY); p_bytes = 64 + 8 * t; dnslen = 1 + (key->key_size * 3)/8 + ISC_SHA1_DIGESTLENGTH; if (r.length < (unsigned int) dnslen) return (ISC_R_NOSPACE); *r.base = t; isc_region_consume(&r, 1); BN_bn2bin_fixed(dsa->q, r.base, ISC_SHA1_DIGESTLENGTH); isc_region_consume(&r, ISC_SHA1_DIGESTLENGTH); BN_bn2bin_fixed(dsa->p, r.base, key->key_size/8); isc_region_consume(&r, p_bytes); BN_bn2bin_fixed(dsa->g, r.base, key->key_size/8); isc_region_consume(&r, p_bytes); BN_bn2bin_fixed(dsa->pub_key, r.base, key->key_size/8); isc_region_consume(&r, p_bytes); isc_buffer_add(data, dnslen); return (ISC_R_SUCCESS); }
static inline isc_result_t towire_sig(ARGS_TOWIRE) { isc_region_t sr; dns_name_t name; dns_offsets_t offsets; REQUIRE(rdata->type == dns_rdatatype_sig); REQUIRE(rdata->length != 0); dns_compress_setmethods(cctx, DNS_COMPRESS_NONE); dns_rdata_toregion(rdata, &sr); /* * type covered: 2 * algorithm: 1 * labels: 1 * original ttl: 4 * signature expiration: 4 * time signed: 4 * key footprint: 2 */ RETERR(mem_tobuffer(target, sr.base, 18)); isc_region_consume(&sr, 18); /* * Signer. */ dns_name_init(&name, offsets); dns_name_fromregion(&name, &sr); isc_region_consume(&sr, name_length(&name)); RETERR(dns_name_towire(&name, cctx, target)); /* * Signature. */ return (mem_tobuffer(target, sr.base, sr.length)); }
static inline isc_result_t additionaldata_mx(ARGS_ADDLDATA) { dns_name_t name; dns_offsets_t offsets; isc_region_t region; REQUIRE(rdata->type == 15); dns_name_init(&name, offsets); dns_rdata_toregion(rdata, ®ion); isc_region_consume(®ion, 2); dns_name_fromregion(&name, ®ion); return ((add)(arg, &name, dns_rdatatype_a)); }
static inline isc_result_t digest_mx(ARGS_DIGEST) { isc_region_t r1, r2; dns_name_t name; REQUIRE(rdata->type == 15); dns_rdata_toregion(rdata, &r1); r2 = r1; isc_region_consume(&r2, 2); r1.length = 2; RETERR((digest)(arg, &r1)); dns_name_init(&name, NULL); dns_name_fromregion(&name, &r2); return (dns_name_digest(&name, digest, arg)); }
static inline isc_result_t digest_in_srv(ARGS_DIGEST) { isc_region_t r1, r2; dns_name_t name; REQUIRE(rdata->type == dns_rdatatype_srv); REQUIRE(rdata->rdclass == dns_rdataclass_in); dns_rdata_toregion(rdata, &r1); r2 = r1; isc_region_consume(&r2, 6); r1.length = 6; RETERR((digest)(arg, &r1)); dns_name_init(&name, NULL); dns_name_fromregion(&name, &r2); return (dns_name_digest(&name, digest, arg)); }
static inline isc_result_t tostruct_soa(ARGS_TOSTRUCT) { isc_region_t region; dns_rdata_soa_t *soa = target; dns_name_t name; isc_result_t result; REQUIRE(rdata->type == 6); REQUIRE(target != NULL); REQUIRE(rdata->length != 0); soa->common.rdclass = rdata->rdclass; soa->common.rdtype = rdata->type; ISC_LINK_INIT(&soa->common, link); dns_rdata_toregion(rdata, ®ion); dns_name_init(&name, NULL); dns_name_fromregion(&name, ®ion); isc_region_consume(®ion, name_length(&name)); dns_name_init(&soa->origin, NULL); RETERR(name_duporclone(&name, mctx, &soa->origin)); dns_name_fromregion(&name, ®ion); isc_region_consume(®ion, name_length(&name)); dns_name_init(&soa->contact, NULL); result = name_duporclone(&name, mctx, &soa->contact); if (result != ISC_R_SUCCESS) goto cleanup; soa->serial = uint32_fromregion(®ion); isc_region_consume(®ion, 4); soa->refresh = uint32_fromregion(®ion); isc_region_consume(®ion, 4); soa->retry = uint32_fromregion(®ion); isc_region_consume(®ion, 4); soa->expire = uint32_fromregion(®ion); isc_region_consume(®ion, 4); soa->minimum = uint32_fromregion(®ion); soa->mctx = mctx; return (ISC_R_SUCCESS); cleanup: if (mctx != NULL) dns_name_free(&soa->origin, mctx); return (ISC_R_NOMEMORY); }
static inline isc_result_t digest_rt(ARGS_DIGEST) { isc_region_t r1, r2; isc_result_t result; dns_name_t name; REQUIRE(rdata->type == 21); dns_rdata_toregion(rdata, &r1); r2 = r1; isc_region_consume(&r2, 2); r1.length = 2; result = (digest)(arg, &r1); if (result != ISC_R_SUCCESS) return (result); dns_name_init(&name, NULL); dns_name_fromregion(&name, &r2); return (dns_name_digest(&name, digest, arg)); }
static inline isc_result_t additionaldata_lp(ARGS_ADDLDATA) { dns_name_t name; dns_offsets_t offsets; isc_region_t region; isc_result_t result; REQUIRE(rdata->type == dns_rdatatype_lp); dns_name_init(&name, offsets); dns_rdata_toregion(rdata, ®ion); isc_region_consume(®ion, 2); dns_name_fromregion(&name, ®ion); result = (add)(arg, &name, dns_rdatatype_l32); if (result != ISC_R_SUCCESS) return (result); return ((add)(arg, &name, dns_rdatatype_l64)); }
static inline isc_result_t fromwire_caa(ARGS_FROMWIRE) { isc_region_t sr; unsigned int len, i; REQUIRE(type == 257); UNUSED(type); UNUSED(rdclass); UNUSED(dctx); UNUSED(options); /* * Flags */ isc_buffer_activeregion(source, &sr); if (sr.length < 2) return (ISC_R_UNEXPECTEDEND); /* * Flags, tag length */ RETERR(mem_tobuffer(target, sr.base, 2)); len = sr.base[1]; isc_region_consume(&sr, 2); isc_buffer_forward(source, 2); /* * Zero length tag fields are illegal. */ if (sr.length < len || len == 0) RETERR(DNS_R_FORMERR); /* Check the Tag's value */ for (i = 0; i < len; i++) if (!alphanumeric[sr.base[i]]) RETERR(DNS_R_FORMERR); /* * Tag + Value */ isc_buffer_forward(source, sr.length); return (mem_tobuffer(target, sr.base, sr.length)); }
static inline isc_boolean_t checknames_mx(ARGS_CHECKNAMES) { isc_region_t region; dns_name_t name; REQUIRE(rdata->type == 15); UNUSED(owner); dns_rdata_toregion(rdata, ®ion); isc_region_consume(®ion, 2); dns_name_init(&name, NULL); dns_name_fromregion(&name, ®ion); if (!dns_name_ishostname(&name, ISC_FALSE)) { if (bad != NULL) dns_name_clone(&name, bad); return (ISC_FALSE); } return (ISC_TRUE); }