static inline isc_result_t
tostruct_in_apl(ARGS_TOSTRUCT) {
dns_rdata_in_apl_t *apl = target;
isc_region_t r;
REQUIRE(rdata->type == dns_rdatatype_apl);
REQUIRE(rdata->rdclass == dns_rdataclass_in);
apl->common.rdclass = rdata->rdclass;
apl->common.rdtype = rdata->type;
ISC_LINK_INIT(&apl->common, link);
dns_rdata_toregion(rdata, &r);
apl->apl_len = r.length;
apl->apl = mem_maybedup(mctx, r.base, r.length);
if (apl->apl == NULL)
return (ISC_R_NOMEMORY);
apl->offset = 0;
apl->mctx = mctx;
return (ISC_R_SUCCESS);
}
static inline isc_result_t
tostruct_opt(ARGS_TOSTRUCT) {
dns_rdata_opt_t *opt = target;
isc_region_t r;
REQUIRE(rdata->type == 41);
REQUIRE(target != NULL);
opt->common.rdclass = rdata->rdclass;
opt->common.rdtype = rdata->type;
ISC_LINK_INIT(&opt->common, link);
dns_rdata_toregion(rdata, &r);
opt->length = r.length;
opt->options = mem_maybedup(mctx, r.base, r.length);
if (opt->options == NULL)
return (ISC_R_NOMEMORY);
opt->offset = 0;
opt->mctx = mctx;
return (ISC_R_SUCCESS);
}
static inline isc_result_t
tostruct_spf(ARGS_TOSTRUCT) {
dns_rdata_spf_t *txt = target;
isc_region_t r;
REQUIRE(rdata->type == 99);
REQUIRE(target != NULL);
txt->common.rdclass = rdata->rdclass;
txt->common.rdtype = rdata->type;
ISC_LINK_INIT(&txt->common, link);
dns_rdata_toregion(rdata, &r);
txt->txt_len = r.length;
txt->txt = mem_maybedup(mctx, r.base, r.length);
if (txt->txt == NULL)
return (ISC_R_NOMEMORY);
txt->offset = 0;
txt->mctx = mctx;
return (ISC_R_SUCCESS);
}
static inline isc_result_t
tostruct_x25(ARGS_TOSTRUCT) {
dns_rdata_x25_t *x25 = target;
isc_region_t r;
REQUIRE(rdata->type == dns_rdatatype_x25);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
x25->common.rdclass = rdata->rdclass;
x25->common.rdtype = rdata->type;
ISC_LINK_INIT(&x25->common, link);
dns_rdata_toregion(rdata, &r);
x25->x25_len = uint8_fromregion(&r);
isc_region_consume(&r, 1);
x25->x25 = mem_maybedup(mctx, r.base, x25->x25_len);
if (x25->x25 == NULL)
return (ISC_R_NOMEMORY);
x25->mctx = mctx;
return (ISC_R_SUCCESS);
}
static inline isc_result_t
tostruct_in_dhcid(ARGS_TOSTRUCT) {
dns_rdata_in_dhcid_t *dhcid = target;
isc_region_t region;
REQUIRE(rdata->type == 49);
REQUIRE(rdata->rdclass == 1);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
dhcid->common.rdclass = rdata->rdclass;
dhcid->common.rdtype = rdata->type;
ISC_LINK_INIT(&dhcid->common, link);
dns_rdata_toregion(rdata, ®ion);
dhcid->dhcid = mem_maybedup(mctx, region.base, region.length);
if (dhcid->dhcid == NULL)
return (ISC_R_NOMEMORY);
dhcid->mctx = mctx;
return (ISC_R_SUCCESS);
}
static inline isc_result_t
tostruct_in_nsap(ARGS_TOSTRUCT) {
dns_rdata_in_nsap_t *nsap = target;
isc_region_t r;
REQUIRE(rdata->type == 22);
REQUIRE(rdata->rdclass == 1);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
nsap->common.rdclass = rdata->rdclass;
nsap->common.rdtype = rdata->type;
ISC_LINK_INIT(&nsap->common, link);
dns_rdata_toregion(rdata, &r);
nsap->nsap_len = r.length;
nsap->nsap = mem_maybedup(mctx, r.base, r.length);
if (nsap->nsap == NULL)
return (ISC_R_NOMEMORY);
nsap->mctx = mctx;
return (ISC_R_SUCCESS);
}
static inline isc_result_t
tostruct_tkey(ARGS_TOSTRUCT) {
dns_rdata_tkey_t *tkey = target;
dns_name_t alg;
isc_region_t sr;
REQUIRE(rdata->type == 249);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
tkey->common.rdclass = rdata->rdclass;
tkey->common.rdtype = rdata->type;
ISC_LINK_INIT(&tkey->common, link);
dns_rdata_toregion(rdata, &sr);
/*
* Algorithm Name.
*/
dns_name_init(&alg, NULL);
dns_name_fromregion(&alg, &sr);
dns_name_init(&tkey->algorithm, NULL);
RETERR(name_duporclone(&alg, mctx, &tkey->algorithm));
isc_region_consume(&sr, name_length(&tkey->algorithm));
/*
* Inception.
*/
tkey->inception = uint32_fromregion(&sr);
isc_region_consume(&sr, 4);
/*
* Expire.
*/
tkey->expire = uint32_fromregion(&sr);
isc_region_consume(&sr, 4);
/*
* Mode.
*/
tkey->mode = uint16_fromregion(&sr);
isc_region_consume(&sr, 2);
/*
* Error.
*/
tkey->error = uint16_fromregion(&sr);
isc_region_consume(&sr, 2);
/*
* Key size.
*/
tkey->keylen = uint16_fromregion(&sr);
isc_region_consume(&sr, 2);
/*
* Key.
*/
tkey->key = mem_maybedup(mctx, sr.base, tkey->keylen);
if (tkey->key == NULL)
goto cleanup;
isc_region_consume(&sr, tkey->keylen);
/*
* Other size.
*/
tkey->otherlen = uint16_fromregion(&sr);
isc_region_consume(&sr, 2);
/*
* Other.
*/
tkey->other = mem_maybedup(mctx, sr.base, tkey->otherlen);
if (tkey->other == NULL)
goto cleanup;
tkey->mctx = mctx;
return (ISC_R_SUCCESS);
cleanup:
if (mctx != NULL)
dns_name_free(&tkey->algorithm, mctx);
if (mctx != NULL && tkey->key != NULL)
isc_mem_free(mctx, tkey->key);
return (ISC_R_NOMEMORY);
}
static inline isc_result_t
tostruct_sig(ARGS_TOSTRUCT) {
isc_region_t sr;
dns_rdata_sig_t *sig = target;
dns_name_t signer;
REQUIRE(rdata->type == dns_rdatatype_sig);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
sig->common.rdclass = rdata->rdclass;
sig->common.rdtype = rdata->type;
ISC_LINK_INIT(&sig->common, link);
dns_rdata_toregion(rdata, &sr);
/*
* Type covered.
*/
sig->covered = uint16_fromregion(&sr);
isc_region_consume(&sr, 2);
/*
* Algorithm.
*/
sig->algorithm = uint8_fromregion(&sr);
isc_region_consume(&sr, 1);
/*
* Labels.
*/
sig->labels = uint8_fromregion(&sr);
isc_region_consume(&sr, 1);
/*
* Original TTL.
*/
sig->originalttl = uint32_fromregion(&sr);
isc_region_consume(&sr, 4);
/*
* Expire time.
*/
sig->timeexpire = uint32_fromregion(&sr);
isc_region_consume(&sr, 4);
/*
* Time signed.
*/
sig->timesigned = uint32_fromregion(&sr);
isc_region_consume(&sr, 4);
/*
* Key ID.
*/
sig->keyid = uint16_fromregion(&sr);
isc_region_consume(&sr, 2);
dns_name_init(&signer, NULL);
dns_name_fromregion(&signer, &sr);
dns_name_init(&sig->signer, NULL);
RETERR(name_duporclone(&signer, mctx, &sig->signer));
isc_region_consume(&sr, name_length(&sig->signer));
/*
* Signature.
*/
sig->siglen = sr.length;
sig->signature = mem_maybedup(mctx, sr.base, sig->siglen);
if (sig->signature == NULL)
goto cleanup;
sig->mctx = mctx;
return (ISC_R_SUCCESS);
cleanup:
if (mctx != NULL)
dns_name_free(&sig->signer, mctx);
return (ISC_R_NOMEMORY);
}
static inline isc_result_t
tostruct_ipseckey(ARGS_TOSTRUCT) {
isc_region_t region;
dns_rdata_ipseckey_t *ipseckey = target;
dns_name_t name;
isc_uint32_t n;
REQUIRE(rdata->type == 45);
REQUIRE(target != NULL);
REQUIRE(rdata->length >= 3);
if (rdata->data[1] > 3U)
return (ISC_R_NOTIMPLEMENTED);
ipseckey->common.rdclass = rdata->rdclass;
ipseckey->common.rdtype = rdata->type;
ISC_LINK_INIT(&ipseckey->common, link);
dns_name_init(&name, NULL);
dns_rdata_toregion(rdata, ®ion);
ipseckey->precedence = uint8_fromregion(®ion);
isc_region_consume(®ion, 1);
ipseckey->gateway_type = uint8_fromregion(®ion);
isc_region_consume(®ion, 1);
ipseckey->algorithm = uint8_fromregion(®ion);
isc_region_consume(®ion, 1);
switch (ipseckey->gateway_type) {
case 0:
break;
case 1:
n = uint32_fromregion(®ion);
ipseckey->in_addr.s_addr = htonl(n);
isc_region_consume(®ion, 4);
break;
case 2:
memmove(ipseckey->in6_addr.s6_addr, region.base, 16);
isc_region_consume(®ion, 16);
break;
case 3:
dns_name_init(&ipseckey->gateway, NULL);
dns_name_fromregion(&name, ®ion);
RETERR(name_duporclone(&name, mctx, &ipseckey->gateway));
isc_region_consume(®ion, name_length(&name));
break;
}
ipseckey->keylength = region.length;
if (ipseckey->keylength != 0U) {
ipseckey->key = mem_maybedup(mctx, region.base,
ipseckey->keylength);
if (ipseckey->key == NULL) {
if (ipseckey->gateway_type == 3)
dns_name_free(&ipseckey->gateway,
ipseckey->mctx);
return (ISC_R_NOMEMORY);
}
} else
ipseckey->key = NULL;
ipseckey->mctx = mctx;
return (ISC_R_SUCCESS);
}
static inline isc_result_t
tostruct_naptr(ARGS_TOSTRUCT) {
dns_rdata_naptr_t *naptr = target;
isc_region_t r;
isc_result_t result;
dns_name_t name;
REQUIRE(rdata->type == dns_rdatatype_naptr);
REQUIRE(target != NULL);
REQUIRE(rdata->length != 0);
naptr->common.rdclass = rdata->rdclass;
naptr->common.rdtype = rdata->type;
ISC_LINK_INIT(&naptr->common, link);
naptr->flags = NULL;
naptr->service = NULL;
naptr->regexp = NULL;
dns_rdata_toregion(rdata, &r);
naptr->order = uint16_fromregion(&r);
isc_region_consume(&r, 2);
naptr->preference = uint16_fromregion(&r);
isc_region_consume(&r, 2);
naptr->flags_len = uint8_fromregion(&r);
isc_region_consume(&r, 1);
INSIST(naptr->flags_len <= r.length);
naptr->flags = mem_maybedup(mctx, r.base, naptr->flags_len);
if (naptr->flags == NULL)
goto cleanup;
isc_region_consume(&r, naptr->flags_len);
naptr->service_len = uint8_fromregion(&r);
isc_region_consume(&r, 1);
INSIST(naptr->service_len <= r.length);
naptr->service = mem_maybedup(mctx, r.base, naptr->service_len);
if (naptr->service == NULL)
goto cleanup;
isc_region_consume(&r, naptr->service_len);
naptr->regexp_len = uint8_fromregion(&r);
isc_region_consume(&r, 1);
INSIST(naptr->regexp_len <= r.length);
naptr->regexp = mem_maybedup(mctx, r.base, naptr->regexp_len);
if (naptr->regexp == NULL)
goto cleanup;
isc_region_consume(&r, naptr->regexp_len);
dns_name_init(&name, NULL);
dns_name_fromregion(&name, &r);
dns_name_init(&naptr->replacement, NULL);
result = name_duporclone(&name, mctx, &naptr->replacement);
if (result != ISC_R_SUCCESS)
goto cleanup;
naptr->mctx = mctx;
return (ISC_R_SUCCESS);
cleanup:
if (mctx != NULL && naptr->flags != NULL)
isc_mem_free(mctx, naptr->flags);
if (mctx != NULL && naptr->service != NULL)
isc_mem_free(mctx, naptr->service);
if (mctx != NULL && naptr->regexp != NULL)
isc_mem_free(mctx, naptr->regexp);
return (ISC_R_NOMEMORY);
}