dns/bind9
dns/bind9
1
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9.git synced 2025-04-18 09:44:09 +03:00
Code

chg: nil: Move application of dns64 to a separate function

Browse Source 
The code in `query_dns64()` that applies the dns64 prefixes to an A rdataset has been moved into the `dns_dns64` module, and `dns_dns64_destroy()` now unlinks the dns64 object from its containing list.

With these changes, we no longer need the list-manipulation API calls, `dns_dns64_next()` and `dns_dns64_unlink()`.

Merge branch 'each-simplify-dns64' into 'main'

See merge request isc-projects/bind9!10324
This commit is contained in:
Evan Hunt 2025-03-27 00:06:22 +00:00
commit 52a04a368b
10 changed files with 126 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
bin/dig/dighost.c
View File

@ -2101,11 +2101,9 @@ insert_soa(dig_lookup_t *lookup) {
&soa, &lookup->rdatabuf);
check_result(result, "isc_rdata_fromstruct");
dns_message_gettemprdatalist(lookup->sendmsg, &rdatalist);
dns_message_gettemprdataset(lookup->sendmsg, &rdataset);
dns_rdatalist_init(rdatalist);
dns_message_gettemprdatalist(lookup->sendmsg, &rdatalist);
rdatalist->type = dns_rdatatype_soa;
rdatalist->rdclass = lookup->rdclass;
ISC_LIST_APPEND(rdatalist->rdata, rdata, link);

4
bin/nsupdate/nsupdate.c
View File

@ -1436,8 +1436,6 @@ make_prereq(char *cmdline, bool ispositive, bool isrrset) {
dns_message_gettemprdata(updatemsg, &rdata);
dns_rdata_init(rdata);
if (isrrset && ispositive) {
retval = parse_rdata(&cmdline, rdataclass, rdatatype, updatemsg,
rdata);
@ -1917,8 +1915,6 @@ update_addordelete(char *cmdline, bool isdelete) {
dns_message_gettemprdata(updatemsg, &rdata);
dns_rdata_init(rdata);
/*
* If this is an add, read the TTL and verify that it's in range.
* If it's a delete, ignore a TTL if present (for compatibility).

89
lib/dns/dns64.c
View File

@ -24,6 +24,7 @@
#include <dns/acl.h>
#include <dns/dns64.h>
#include <dns/rdata.h>
#include <dns/rdatalist.h>
#include <dns/rdataset.h>
struct dns_dns64 {
@ -103,7 +104,7 @@ dns_dns64_create(isc_mem_t *mctx, const isc_netaddr_t *prefix,
}
void
dns_dns64_destroy(dns_dns64_t **dns64p) {
dns_dns64_destroy(dns_dns64list_t *list, dns_dns64_t **dns64p) {
dns_dns64_t *dns64;
REQUIRE(dns64p != NULL && *dns64p != NULL);
@ -111,7 +112,7 @@ dns_dns64_destroy(dns_dns64_t **dns64p) {
dns64 = *dns64p;
*dns64p = NULL;
REQUIRE(!ISC_LINK_LINKED(dns64, link));
ISC_LIST_UNLINK(*list, dns64, link);
if (dns64->clients != NULL) {
dns_acl_detach(&dns64->clients);
@ -193,22 +194,11 @@ dns_dns64_aaaafroma(const dns_dns64_t *dns64, const isc_netaddr_t *reqaddr,
return ISC_R_SUCCESS;
}
dns_dns64_t *
dns_dns64_next(dns_dns64_t *dns64) {
dns64 = ISC_LIST_NEXT(dns64, link);
return dns64;
}
void
dns_dns64_append(dns_dns64list_t *list, dns_dns64_t *dns64) {
ISC_LIST_APPEND(*list, dns64, link);
}
void
dns_dns64_unlink(dns_dns64list_t *list, dns_dns64_t *dns64) {
ISC_LIST_UNLINK(*list, dns64, link);
}
bool
dns_dns64_aaaaok(const dns_dns64_t *dns64, const isc_netaddr_t *reqaddr,
const dns_name_t *reqsigner, dns_aclenv_t *env,
@ -481,3 +471,76 @@ dns_dns64_findprefix(dns_rdataset_t *rdataset, isc_netprefix_t *prefix,
*len = count;
return ISC_R_SUCCESS;
}
isc_result_t
dns_dns64_apply(isc_mem_t *mctx, dns_dns64list_t dns64s, unsigned int count,
dns_message_t *message, dns_aclenv_t *env, isc_sockaddr_t *peer,
dns_name_t *reqsigner, unsigned int flags, dns_rdataset_t *a,
dns_rdataset_t **aaaap) {
isc_result_t result;
dns_rdatalist_t *aaaalist = NULL;
isc_buffer_t *buffer = NULL;
isc_netaddr_t netaddr;
REQUIRE(aaaap != NULL && *aaaap == NULL);
REQUIRE(a->type == dns_rdatatype_a);
isc_netaddr_fromsockaddr(&netaddr, peer);
isc_buffer_allocate(mctx, &buffer, count * 16 * dns_rdataset_count(a));
dns_message_gettemprdatalist(message, &aaaalist);
aaaalist->rdclass = dns_rdataclass_in;
aaaalist->type = dns_rdatatype_aaaa;
for (result = dns_rdataset_first(a); result == ISC_R_SUCCESS;
result = dns_rdataset_next(a))
{
for (dns_dns64_t *dns64 = ISC_LIST_HEAD(dns64s); dns64 != NULL;
dns64 = ISC_LIST_NEXT(dns64, link))
{
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_t *dns64_rdata = NULL;
isc_region_t r;
dns_rdataset_current(a, &rdata);
isc_buffer_availableregion(buffer, &r);
INSIST(r.length >= 16);
result = dns_dns64_aaaafroma(dns64, &netaddr, reqsigner,
env, flags, rdata.data,
r.base);
if (result != ISC_R_SUCCESS) {
continue;
}
isc_buffer_add(buffer, 16);
isc_buffer_remainingregion(buffer, &r);
isc_buffer_forward(buffer, 16);
dns_message_gettemprdata(message, &dns64_rdata);
dns_rdata_fromregion(dns64_rdata, dns_rdataclass_in,
dns_rdatatype_aaaa, &r);
ISC_LIST_APPEND(aaaalist->rdata, dns64_rdata, link);
}
}
if (!ISC_LIST_EMPTY(aaaalist->rdata)) {
dns_rdataset_t *aaaa = NULL;
dns_message_gettemprdataset(message, &aaaa);
dns_rdatalist_tordataset(aaaalist, aaaa);
dns_message_takebuffer(message, &buffer);
aaaa->trust = a->trust;
*aaaap = aaaa;
return ISC_R_SUCCESS;
}
/* No applicable dns64; free the resources */
isc_buffer_free(&buffer);
for (dns_rdata_t *rdata = ISC_LIST_HEAD(aaaalist->rdata); rdata != NULL;
rdata = ISC_LIST_HEAD(aaaalist->rdata))
{
ISC_LIST_UNLINK(aaaalist->rdata, rdata, link);
dns_message_puttemprdata(message, &rdata);
}
dns_message_puttemprdatalist(message, &aaaalist);
return ISC_R_NOMORE;
}

34
lib/dns/include/dns/dns64.h
View File

@ -82,11 +82,9 @@ dns_dns64_create(isc_mem_t *mctx, const isc_netaddr_t *prefix,
*/
void
dns_dns64_destroy(dns_dns64_t **dns64p);
dns_dns64_destroy(dns_dns64list_t *list, dns_dns64_t **dns64p);
/*
* Destroys a dns64 record.
*
* Requires the record to not be linked.
* Unlinks a dns64 record from list, then destroys it.
*/
isc_result_t
@ -121,24 +119,12 @@ dns_dns64_aaaafroma(const dns_dns64_t *dns64, const isc_netaddr_t *reqaddr,
* DNS_R_DISALLOWED if there is no match.
*/
dns_dns64_t *
dns_dns64_next(dns_dns64_t *dns64);
/*
* Return the next dns64 record in the list.
*/
void
dns_dns64_append(dns_dns64list_t *list, dns_dns64_t *dns64);
/*
* Append the dns64 record to the list.
*/
void
dns_dns64_unlink(dns_dns64list_t *list, dns_dns64_t *dns64);
/*
* Unlink the dns64 record from the list.
*/
bool
dns_dns64_aaaaok(const dns_dns64_t *dns64, const isc_netaddr_t *reqaddr,
const dns_name_t *reqsigner, dns_aclenv_t *env,
@ -182,3 +168,19 @@ dns_dns64_findprefix(dns_rdataset_t *rdataset, isc_netprefix_t *prefix,
* into 'prefix'.
* ISC_R_NOTFOUND no prefixes where found.
*/
isc_result_t
dns_dns64_apply(isc_mem_t *mctx, dns_dns64list_t dns64s, unsigned int count,
dns_message_t *message, dns_aclenv_t *env, isc_sockaddr_t *peer,
dns_name_t *reqsigner, unsigned int flags, dns_rdataset_t *a,
dns_rdataset_t **aaaap);
/*
* Apply a list of 'count' dns64 prefixes in the list 'dns64s'
* to an 'a' rdataset, based 'peer', 'reqsigner', 'env', and 'flags'.
* If synthesis is performed then return an AAAA rdataset in '*aaaap'.
*
* Returns:
* ISC_R_SUCCESS
* ISC_R_NOMORE The list was fully iterated and no
* dns64 conversions were applied
*/

3
lib/dns/message.c
View File

@ -319,6 +319,7 @@ newrdata(dns_message_t *msg) {
rdata = ISC_LIST_HEAD(msg->freerdata);
if (rdata != NULL) {
ISC_LIST_UNLINK(msg->freerdata, rdata, link);
dns_rdata_reset(rdata);
return rdata;
}
@ -349,6 +350,7 @@ newrdatalist(dns_message_t *msg) {
rdatalist = ISC_LIST_HEAD(msg->freerdatalist);
if (rdatalist != NULL) {
ISC_LIST_UNLINK(msg->freerdatalist, rdatalist, link);
dns_rdatalist_init(rdatalist);
goto out;
}
@ -2790,7 +2792,6 @@ dns_message_setquerytsig(dns_message_t *msg, isc_buffer_t *querytsig) {
isc_buffer_allocate(msg->mctx, &buf, r.length);
isc_buffer_putmem(buf, r.base, r.length);
isc_buffer_usedregion(buf, &r);
dns_rdata_init(rdata);
dns_rdata_fromregion(rdata, dns_rdataclass_any, dns_rdatatype_tsig, &r);
dns_message_takebuffer(msg, &buf);
ISC_LIST_APPEND(list->rdata, rdata, link);

3
lib/dns/view.c
View File

@ -326,8 +326,7 @@ destroy(dns_view_t *view) {
for (dns64 = ISC_LIST_HEAD(view->dns64); dns64 != NULL;
dns64 = ISC_LIST_HEAD(view->dns64))
{
dns_dns64_unlink(&view->dns64, dns64);
dns_dns64_destroy(&dns64);
dns_dns64_destroy(&view->dns64, &dns64);
}
if (view->managed_keys != NULL) {
dns_zone_detach(&view->managed_keys);

2
lib/dns/xfrin.c
View File

@ -1517,11 +1517,9 @@ tuple2msgname(dns_difftuple_t *tuple, dns_message_t *msg, dns_name_t **target) {
REQUIRE(target != NULL && *target == NULL);
dns_message_gettemprdata(msg, &rdata);
dns_rdata_init(rdata);
dns_rdata_clone(&tuple->rdata, rdata);
dns_message_gettemprdatalist(msg, &rdl);
dns_rdatalist_init(rdl);
rdl->type = tuple->rdata.type;
rdl->rdclass = tuple->rdata.rdclass;
rdl->ttl = tuple->ttl;

1
lib/dns/zone.c
View File

@ -15476,7 +15476,6 @@ notify_createmessage(dns_zone_t *zone, unsigned int flags,
isc_buffer_allocate(zone->mctx, &b, r.length);
isc_buffer_putmem(b, r.base, r.length);
isc_buffer_usedregion(b, &r);
dns_rdata_init(temprdata);
dns_rdata_fromregion(temprdata, rdata.rdclass, rdata.type, &r);
dns_message_takebuffer(message, &b);
result = dns_rdataset_next(&rdataset);

165
lib/ns/query.c
View File

@ -8182,22 +8182,14 @@ cleanup:
static isc_result_t
query_dns64(query_ctx_t *qctx) {
ns_client_t *client = qctx->client;
dns_aclenv_t *env = client->manager->aclenv;
dns_name_t *name, *mname;
dns_rdata_t *dns64_rdata;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdatalist_t *dns64_rdatalist;
dns_rdataset_t *dns64_rdataset;
dns_rdataset_t *mrdataset;
isc_buffer_t *buffer;
isc_region_t r;
isc_result_t result;
ns_client_t *client = qctx->client;
dns_name_t *name = NULL, *mname = NULL;
dns_rdataset_t *mrdataset = NULL;
dns_rdataset_t *dns64_rdataset = NULL;
dns_view_t *view = client->view;
isc_netaddr_t netaddr;
dns_dns64_t *dns64;
unsigned int flags = 0;
const dns_section_t section = DNS_SECTION_ANSWER;
unsigned int flags = 0;
/*%
* To the current response for 'qctx->client', add the answer RRset
@ -8215,12 +8207,6 @@ query_dns64(query_ctx_t *qctx) {
qctx->qtype = qctx->type = dns_rdatatype_aaaa;
name = qctx->fname;
mname = NULL;
mrdataset = NULL;
buffer = NULL;
dns64_rdata = NULL;
dns64_rdataset = NULL;
dns64_rdatalist = NULL;
result = dns_message_findname(
client->message, section, name, dns_rdatatype_aaaa,
qctx->rdataset->covers, &mname, &mrdataset);
@ -8256,28 +8242,6 @@ query_dns64(query_ctx_t *qctx) {
client->query.attributes &= ~NS_QUERYATTR_SECURE;
}
isc_netaddr_fromsockaddr(&netaddr, &client->peeraddr);
isc_buffer_allocate(client->manager->mctx, &buffer,
view->dns64cnt * 16 *
dns_rdataset_count(qctx->rdataset));
dns_message_gettemprdataset(client->message, &dns64_rdataset);
dns_message_gettemprdatalist(client->message, &dns64_rdatalist);
dns_rdatalist_init(dns64_rdatalist);
dns64_rdatalist->rdclass = dns_rdataclass_in;
dns64_rdatalist->type = dns_rdatatype_aaaa;
if (client->query.dns64_ttl != UINT32_MAX) {
dns64_rdatalist->ttl = ISC_MIN(qctx->rdataset->ttl,
client->query.dns64_ttl);
} else {
dns64_rdatalist->ttl = ISC_MIN(qctx->rdataset->ttl, 600);
}
if (RECURSIONOK(client)) {
flags |= DNS_DNS64_RECURSIVE;
}
/*
* We use the signatures from the A lookup to set DNS_DNS64_DNSSEC
* as this provides a easy way to see if the answer was signed.
@ -8288,78 +8252,35 @@ query_dns64(query_ctx_t *qctx) {
flags |= DNS_DNS64_DNSSEC;
}
for (result = dns_rdataset_first(qctx->rdataset);
result == ISC_R_SUCCESS;
result = dns_rdataset_next(qctx->rdataset))
{
for (dns64 = ISC_LIST_HEAD(client->view->dns64); dns64 != NULL;
dns64 = dns_dns64_next(dns64))
{
dns_rdataset_current(qctx->rdataset, &rdata);
isc_buffer_availableregion(buffer, &r);
INSIST(r.length >= 16);
result = dns_dns64_aaaafroma(dns64, &netaddr,
client->signer, env, flags,
rdata.data, r.base);
if (result != ISC_R_SUCCESS) {
dns_rdata_reset(&rdata);
continue;
}
isc_buffer_add(buffer, 16);
isc_buffer_remainingregion(buffer, &r);
isc_buffer_forward(buffer, 16);
dns_message_gettemprdata(client->message, &dns64_rdata);
dns_rdata_init(dns64_rdata);
dns_rdata_fromregion(dns64_rdata, dns_rdataclass_in,
dns_rdatatype_aaaa, &r);
ISC_LIST_APPEND(dns64_rdatalist->rdata, dns64_rdata,
link);
dns64_rdata = NULL;
dns_rdata_reset(&rdata);
}
if (RECURSIONOK(client)) {
flags |= DNS_DNS64_RECURSIVE;
}
if (result != ISC_R_NOMORE) {
result = dns_dns64_apply(
client->manager->mctx, view->dns64, view->dns64cnt,
client->message, client->manager->aclenv, &client->peeraddr,
client->signer, flags, qctx->rdataset, &dns64_rdataset);
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
if (ISC_LIST_EMPTY(dns64_rdatalist->rdata)) {
goto cleanup;
}
dns_rdatalist_tordataset(dns64_rdatalist, dns64_rdataset);
dns_rdataset_setownercase(dns64_rdataset, mname);
client->query.attributes |= NS_QUERYATTR_NOADDITIONAL;
dns64_rdataset->trust = qctx->rdataset->trust;
if (client->query.dns64_ttl != UINT32_MAX) {
dns64_rdataset->ttl = ISC_MIN(qctx->rdataset->ttl,
client->query.dns64_ttl);
} else {
dns64_rdataset->ttl = ISC_MIN(qctx->rdataset->ttl, 600);
}
query_addtoname(mname, dns64_rdataset);
query_setorder(qctx, mname, dns64_rdataset);
dns64_rdataset = NULL;
dns64_rdatalist = NULL;
dns_message_takebuffer(client->message, &buffer);
inc_stats(client, ns_statscounter_dns64);
result = ISC_R_SUCCESS;
cleanup:
if (buffer != NULL) {
isc_buffer_free(&buffer);
}
if (dns64_rdataset != NULL) {
dns_message_puttemprdataset(client->message, &dns64_rdataset);
}
if (dns64_rdatalist != NULL) {
for (dns64_rdata = ISC_LIST_HEAD(dns64_rdatalist->rdata);
dns64_rdata != NULL;
dns64_rdata = ISC_LIST_HEAD(dns64_rdatalist->rdata))
{
ISC_LIST_UNLINK(dns64_rdatalist->rdata, dns64_rdata,
link);
dns_message_puttemprdata(client->message, &dns64_rdata);
}
dns_message_puttemprdatalist(client->message, &dns64_rdatalist);
}
CTRACE(ISC_LOG_DEBUG(3), "query_dns64: done");
return result;
@ -8368,13 +8289,10 @@ cleanup:
static void
query_filter64(query_ctx_t *qctx) {
ns_client_t *client = qctx->client;
dns_name_t *name, *mname;
dns_rdata_t *myrdata;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdatalist_t *myrdatalist;
dns_rdataset_t *myrdataset;
isc_buffer_t *buffer;
isc_region_t r;
dns_name_t *name = NULL, *mname = NULL;
dns_rdatalist_t *myrdatalist = NULL;
dns_rdataset_t *myrdataset = NULL;
isc_buffer_t *buffer = NULL;
isc_result_t result;
unsigned int i;
const dns_section_t section = DNS_SECTION_ANSWER;
@ -8386,11 +8304,6 @@ query_filter64(query_ctx_t *qctx) {
dns_rdataset_count(qctx->rdataset));
name = qctx->fname;
mname = NULL;
buffer = NULL;
myrdata = NULL;
myrdataset = NULL;
myrdatalist = NULL;
result = dns_message_findname(
client->message, section, name, dns_rdatatype_aaaa,
qctx->rdataset->covers, &mname, &myrdataset);
@ -8425,7 +8338,6 @@ query_filter64(query_ctx_t *qctx) {
dns_message_gettemprdataset(client->message, &myrdataset);
dns_message_gettemprdatalist(client->message, &myrdatalist);
dns_rdatalist_init(myrdatalist);
myrdatalist->rdclass = dns_rdataclass_in;
myrdatalist->type = dns_rdatatype_aaaa;
myrdatalist->ttl = qctx->rdataset->ttl;
@ -8435,6 +8347,10 @@ query_filter64(query_ctx_t *qctx) {
result == ISC_R_SUCCESS;
result = dns_rdataset_next(qctx->rdataset))
{
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_t *myrdata = NULL;
isc_region_t r;
if (!client->query.dns64_aaaaok[i++]) {
continue;
}
@ -8444,15 +8360,9 @@ query_filter64(query_ctx_t *qctx) {
isc_buffer_remainingregion(buffer, &r);
isc_buffer_forward(buffer, rdata.length);
dns_message_gettemprdata(client->message, &myrdata);
dns_rdata_init(myrdata);
dns_rdata_fromregion(myrdata, dns_rdataclass_in,
dns_rdatatype_aaaa, &r);
ISC_LIST_APPEND(myrdatalist->rdata, myrdata, link);
myrdata = NULL;
dns_rdata_reset(&rdata);
}
if (result != ISC_R_NOMORE) {
goto cleanup;
}
dns_rdatalist_tordataset(myrdatalist, myrdataset);
@ -8470,30 +8380,11 @@ query_filter64(query_ctx_t *qctx) {
query_addtoname(mname, myrdataset);
query_setorder(qctx, mname, myrdataset);
myrdataset = NULL;
myrdatalist = NULL;
dns_message_takebuffer(client->message, &buffer);
cleanup:
if (buffer != NULL) {
isc_buffer_free(&buffer);
}
if (myrdataset != NULL) {
dns_message_puttemprdataset(client->message, &myrdataset);
}
if (myrdatalist != NULL) {
for (myrdata = ISC_LIST_HEAD(myrdatalist->rdata);
myrdata != NULL;
myrdata = ISC_LIST_HEAD(myrdatalist->rdata))
{
ISC_LIST_UNLINK(myrdatalist->rdata, myrdata, link);
dns_message_puttemprdata(client->message, &myrdata);
}
dns_message_puttemprdatalist(client->message, &myrdatalist);
}
if (qctx->dbuf != NULL) {
ns_client_releasename(client, &name);
}

1
lib/ns/xfrout.c
View File

@ -1544,7 +1544,6 @@ sendstream(xfrout_ctx_t *xfr) {
isc_buffer_availableregion(&xfr->buf, &r);
r.length = rdata->length;
isc_buffer_putmem(&xfr->buf, rdata->data, rdata->length);
dns_rdata_init(msgrdata);
dns_rdata_fromregion(msgrdata, rdata->rdclass, rdata->type, &r);
dns_message_gettemprdatalist(msg, &msgrdl);