upstream/bind9
1
0
Fork 0
mirror of https://github.com/isc-projects/bind9.git synced 2026-06-04 20:02:05 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch '3797-part7-resolver-refactoring' into 'main'

Browse source 
refactor dns_resolver to use loop callbacks

See merge request isc-projects/bind9!7372
This commit is contained in:
Ondřej Surý 2023-02-16 16:50:46 +00:00
commit 5a028a40b6
20 changed files with 574 additions and 746 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
bin/delv/delv.c
View file

@ -1828,7 +1828,7 @@ main(int argc, char *argv[]) {
/* Create client */
isc_tlsctx_cache_create(mctx, &tlsctx_client_cache);
result = dns_client_create(mctx, loopmgr, taskmgr, netmgr, 0,
result = dns_client_create(mctx, loopmgr, netmgr, 0,
tlsctx_client_cache, &client, srcaddr4,
srcaddr6);
if (result != ISC_R_SUCCESS) {

44
bin/named/server.c
View file

@ -1120,7 +1120,7 @@ configure_view_dnsseckeys(dns_view_t *view, const cfg_obj_t *vconfig,
return (ISC_R_UNEXPECTED);
}
result = dns_view_initntatable(view, named_g_taskmgr, named_g_loopmgr);
result = dns_view_initntatable(view, named_g_loopmgr);
if (result != ISC_R_SUCCESS) {
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
@ -4756,9 +4756,9 @@ configure_view(dns_view_t *view, dns_viewlist_t *viewlist, cfg_obj_t *config,
ndisp = 4 * ISC_MIN(named_g_udpdisp, MAX_UDP_DISPATCH);
CHECK(dns_view_createresolver(
view, named_g_loopmgr, named_g_taskmgr, ndisp, named_g_netmgr,
resopts, named_g_server->tlsctx_client_cache,
named_g_dispatchmgr, dispatch4, dispatch6));
view, named_g_loopmgr, ndisp, named_g_netmgr, resopts,
named_g_server->tlsctx_client_cache, named_g_dispatchmgr,
dispatch4, dispatch6));
if (resstats == NULL) {
CHECK(isc_stats_create(mctx, &resstats,
@ -7113,7 +7113,7 @@ heartbeat_timer_tick(void *arg) {
typedef struct {
isc_mem_t *mctx;
isc_task_t *task;
isc_loop_t *loop;
dns_fetch_t *fetch;
dns_view_t *view;
dns_fixedname_t tatname;
@ -7136,26 +7136,24 @@ cid(const void *a, const void *b) {
}
static void
tat_done(isc_task_t *task, isc_event_t *event) {
dns_fetchevent_t *devent;
ns_tat_t *tat;
tat_done(void *arg) {
dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg;
ns_tat_t *tat = NULL;
INSIST(event != NULL && event->ev_type == DNS_EVENT_FETCHDONE);
INSIST(event->ev_arg != NULL);
INSIST(resp != NULL && resp->type == FETCHDONE);
UNUSED(task);
tat = resp->arg;
tat = event->ev_arg;
devent = (dns_fetchevent_t *)event;
INSIST(tat != NULL);
/* Free resources which are not of interest */
if (devent->node != NULL) {
dns_db_detachnode(devent->db, &devent->node);
if (resp->node != NULL) {
dns_db_detachnode(resp->db, &resp->node);
}
if (devent->db != NULL) {
dns_db_detach(&devent->db);
if (resp->db != NULL) {
dns_db_detach(&resp->db);
}
isc_event_free(&event);
isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp));
dns_resolver_destroyfetch(&tat->fetch);
if (dns_rdataset_isassociated(&tat->rdataset)) {
dns_rdataset_disassociate(&tat->rdataset);
@ -7164,13 +7162,12 @@ tat_done(isc_task_t *task, isc_event_t *event) {
dns_rdataset_disassociate(&tat->sigrdataset);
}
dns_view_detach(&tat->view);
isc_task_detach(&tat->task);
isc_mem_putanddetach(&tat->mctx, tat, sizeof(*tat));
}
struct dotat_arg {
dns_view_t *view;
isc_task_t *task;
isc_loop_t *loop;
};
/*%
@ -7295,7 +7292,7 @@ tat_send(void *arg) {
result = dns_resolver_createfetch(
tat->view->resolver, tatname, dns_rdatatype_null,
domain, &nameservers, NULL, NULL, 0, 0, 0, NULL,
tat->task, tat_done, tat, &tat->rdataset,
tat->loop, tat_done, tat, &tat->rdataset,
&tat->sigrdataset, &tat->fetch);
}
@ -7316,7 +7313,6 @@ tat_send(void *arg) {
if (result != ISC_R_SUCCESS) {
dns_view_detach(&tat->view);
isc_task_detach(&tat->task);
isc_mem_putanddetach(&tat->mctx, tat, sizeof(*tat));
}
}
@ -7348,7 +7344,7 @@ dotat(dns_keytable_t *keytable, dns_keynode_t *keynode, dns_name_t *keyname,
return;
}
isc_mem_attach(view->mctx, &tat->mctx);
isc_task_attach(dotat_arg->task, &tat->task);
tat->loop = dotat_arg->loop;
dns_view_attach(view, &tat->view);
/*
@ -7389,7 +7385,7 @@ tat_timer_tick(void *arg) {
}
dotat_arg.view = view;
dotat_arg.task = server->task;
dotat_arg.loop = named_g_mainloop;
(void)dns_keytable_forall(secroots, dotat, &dotat_arg);
dns_keytable_detach(&secroots);
}

110
lib/dns/adb.c
View file

@ -102,10 +102,8 @@ struct dns_adb {
isc_mem_t *hmctx;
dns_view_t *view;
dns_resolver_t *res;
size_t nloops;
isc_taskmgr_t *taskmgr;
isc_task_t **tasks;
isc_loopmgr_t *loopmgr;
isc_refcount_t references;
@ -667,12 +665,14 @@ import_rdataset(dns_adbname_t *adbname, dns_rdataset_t *rdataset,
*/
static void
expire_name(dns_adbname_t *adbname, dns_adbstatus_t astat) {
REQUIRE(DNS_ADBNAME_VALID(adbname));
REQUIRE(DNS_ADB_VALID(adbname->adb));
isc_result_t result;
REQUIRE(DNS_ADBNAME_VALID(adbname));
dns_adb_t *adb = adbname->adb;
REQUIRE(DNS_ADB_VALID(adb));
DP(DEF_LEVEL, "killing name %p", adbname);
/*
@ -704,7 +704,7 @@ expire_name(dns_adbname_t *adbname, dns_adbstatus_t astat) {
/* ... and LRU list */
ISC_LIST_UNLINK(adb->names_lru, adbname, link);
dns_adbname_detach(&adbname);
dns_adbname_unref(adbname);
}
/*
@ -1913,11 +1913,6 @@ destroy(dns_adb_t *adb) {
isc_mutex_destroy(&adb->lock);
isc_refcount_destroy(&adb->references);
for (size_t i = 0; i < adb->nloops; i++) {
isc_task_detach(&adb->tasks[i]);
}
isc_mem_put(adb->mctx, adb->tasks, adb->nloops * sizeof(adb->tasks[0]));
isc_stats_detach(&adb->stats);
dns_resolver_detach(&adb->res);
dns_view_weakdetach(&adb->view);
@ -1936,19 +1931,17 @@ ISC_REFCOUNT_IMPL(dns_adb, destroy);
isc_result_t
dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_loopmgr_t *loopmgr,
isc_taskmgr_t *taskmgr, dns_adb_t **newadb) {
dns_adb_t **newadb) {
dns_adb_t *adb = NULL;
isc_result_t result;
REQUIRE(mem != NULL);
REQUIRE(view != NULL);
REQUIRE(taskmgr != NULL);
REQUIRE(newadb != NULL && *newadb == NULL);
adb = isc_mem_get(mem, sizeof(dns_adb_t));
*adb = (dns_adb_t){
.taskmgr = taskmgr,
.nloops = isc_loopmgr_nloops(loopmgr),
.loopmgr = loopmgr,
.names_lru = ISC_LIST_INITIALIZER,
.entries_lru = ISC_LIST_INITIALIZER,
};
@ -1979,22 +1972,9 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_loopmgr_t *loopmgr,
isc_mutex_init(&adb->lock);
/*
* Allocate an internal task.
*/
adb->tasks = isc_mem_getx(
adb->mctx, adb->nloops * sizeof(adb->tasks[0]), ISC_MEM_ZERO);
for (size_t i = 0; i < adb->nloops; i++) {
result = isc_task_create(adb->taskmgr, &adb->tasks[i], i);
if (result != ISC_R_SUCCESS) {
goto free_tasks;
}
isc_task_setname(adb->tasks[i], "ADB", adb);
}
result = isc_stats_create(adb->mctx, &adb->stats, dns_adbstats_max);
if (result != ISC_R_SUCCESS) {
goto free_tasks;
goto free_lock;
}
set_adbstat(adb, 0, dns_adbstats_nnames);
@ -2007,14 +1987,7 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_loopmgr_t *loopmgr,
*newadb = adb;
return (ISC_R_SUCCESS);
free_tasks:
for (size_t i = 0; i < adb->nloops; i++) {
if (adb->tasks[i] != NULL) {
isc_task_detach(&adb->tasks[i]);
}
}
isc_mem_put(adb->mctx, adb->tasks, adb->nloops * sizeof(adb->tasks[0]));
free_lock:
isc_mutex_destroy(&adb->lock);
isc_rwlock_destroy(&adb->entries_lock);
@ -2062,7 +2035,7 @@ dns_adb_shutdown(dns_adb_t *adb) {
* structure for each found and append it to the linked list
* of addresses for this header.
*
* - Name found, queries pending. In this case, if a task was
* - Name found, queries pending. In this case, if a loop was
* passed in, allocate a job id, attach it to the name's job
* list and remember to tell the caller that there will be
* more info coming later.
@ -2920,9 +2893,9 @@ dbfind_name(dns_adbname_t *adbname, isc_stdtime_t now, dns_rdatatype_t rdtype) {
}
static void
fetch_callback(isc_task_t *task, isc_event_t *ev) {
dns_fetchevent_t *dev = (dns_fetchevent_t *)ev;
dns_adbname_t *name = NULL;
fetch_callback(void *arg) {
dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg;
dns_adbname_t *name = resp->arg;
dns_adb_t *adb = NULL;
dns_adbfetch_t *fetch = NULL;
dns_adbstatus_t astat = DNS_ADB_NOMOREADDRESSES;
@ -2930,10 +2903,6 @@ fetch_callback(isc_task_t *task, isc_event_t *ev) {
isc_result_t result;
unsigned int address_type;
UNUSED(task);
name = ev->ev_arg;
REQUIRE(DNS_ADBNAME_VALID(name));
dns_adb_attach(name->adb, &adb);
@ -2943,12 +2912,12 @@ fetch_callback(isc_task_t *task, isc_event_t *ev) {
INSIST(NAME_FETCH_A(name) || NAME_FETCH_AAAA(name));
address_type = 0;
if (NAME_FETCH_A(name) && (name->fetch_a->fetch == dev->fetch)) {
if (NAME_FETCH_A(name) && (name->fetch_a->fetch == resp->fetch)) {
address_type = DNS_ADBFIND_INET;
fetch = name->fetch_a;
name->fetch_a = NULL;
} else if (NAME_FETCH_AAAA(name) &&
(name->fetch_aaaa->fetch == dev->fetch))
(name->fetch_aaaa->fetch == resp->fetch))
{
address_type = DNS_ADBFIND_INET6;
fetch = name->fetch_aaaa;
@ -2962,11 +2931,11 @@ fetch_callback(isc_task_t *task, isc_event_t *ev) {
/*
* Cleanup things we don't care about.
*/
if (dev->node != NULL) {
dns_db_detachnode(dev->db, &dev->node);
if (resp->node != NULL) {
dns_db_detachnode(resp->db, &resp->node);
}
if (dev->db != NULL) {
dns_db_detach(&dev->db);
if (resp->db != NULL) {
dns_db_detach(&resp->db);
}
/*
@ -2983,16 +2952,16 @@ fetch_callback(isc_task_t *task, isc_event_t *ev) {
/*
* If we got a negative cache response, remember it.
*/
if (NCACHE_RESULT(dev->result)) {
dev->rdataset->ttl = ttlclamp(dev->rdataset->ttl);
if (NCACHE_RESULT(resp->result)) {
resp->rdataset->ttl = ttlclamp(resp->rdataset->ttl);
if (address_type == DNS_ADBFIND_INET) {
DP(NCACHE_LEVEL,
"adb fetch name %p: "
"caching negative entry for A (ttl %u)",
name, dev->rdataset->ttl);
name, resp->rdataset->ttl);
name->expire_v4 = ISC_MIN(name->expire_v4,
dev->rdataset->ttl + now);
if (dev->result == DNS_R_NCACHENXDOMAIN) {
resp->rdataset->ttl + now);
if (resp->result == DNS_R_NCACHENXDOMAIN) {
name->fetch_err = FIND_ERR_NXDOMAIN;
} else {
name->fetch_err = FIND_ERR_NXRRSET;
@ -3002,10 +2971,10 @@ fetch_callback(isc_task_t *task, isc_event_t *ev) {
DP(NCACHE_LEVEL,
"adb fetch name %p: "
"caching negative entry for AAAA (ttl %u)",
name, dev->rdataset->ttl);
name, resp->rdataset->ttl);
name->expire_v6 = ISC_MIN(name->expire_v6,
dev->rdataset->ttl + now);
if (dev->result == DNS_R_NCACHENXDOMAIN) {
resp->rdataset->ttl + now);
if (resp->result == DNS_R_NCACHENXDOMAIN) {
name->fetch6_err = FIND_ERR_NXDOMAIN;
} else {
name->fetch6_err = FIND_ERR_NXRRSET;
@ -3018,16 +2987,16 @@ fetch_callback(isc_task_t *task, isc_event_t *ev) {
/*
* Handle CNAME/DNAME.
*/
if (dev->result == DNS_R_CNAME || dev->result == DNS_R_DNAME) {
dev->rdataset->ttl = ttlclamp(dev->rdataset->ttl);
if (resp->result == DNS_R_CNAME || resp->result == DNS_R_DNAME) {
resp->rdataset->ttl = ttlclamp(resp->rdataset->ttl);
clean_target(adb, &name->target);
name->expire_target = INT_MAX;
result = set_target(adb, &name->name, dev->foundname,
dev->rdataset, &name->target);
result = set_target(adb, &name->name, resp->foundname,
resp->rdataset, &name->target);
if (result == ISC_R_SUCCESS) {
DP(NCACHE_LEVEL,
"adb fetch name %p: caching alias target", name);
name->expire_target = dev->rdataset->ttl + now;
name->expire_target = resp->rdataset->ttl + now;
}
goto check_result;
}
@ -3036,13 +3005,13 @@ fetch_callback(isc_task_t *task, isc_event_t *ev) {
* Did we get back junk? If so, and there are no more fetches
* sitting out there, tell all the finds about it.
*/
if (dev->result != ISC_R_SUCCESS) {
if (resp->result != ISC_R_SUCCESS) {
char buf[DNS_NAME_FORMATSIZE];
dns_name_format(&name->name, buf, sizeof(buf));
DP(DEF_LEVEL, "adb: fetch of '%s' %s failed: %s", buf,
address_type == DNS_ADBFIND_INET ? "A" : "AAAA",
isc_result_totext(dev->result));
isc_result_totext(resp->result));
/*
* Don't record a failure unless this is the initial
* fetch of a chain.
@ -3081,7 +3050,7 @@ check_result:
out:
dns_resolver_destroyfetch(&fetch->fetch);
free_adbfetch(adb, &fetch);
isc_event_free(&ev);
isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp));
if (astat != DNS_ADB_CANCELED) {
clean_finds_at_name(name, astat, address_type);
}
@ -3101,7 +3070,6 @@ fetch_name(dns_adbname_t *adbname, bool start_at_zone, unsigned int depth,
dns_rdataset_t rdataset;
dns_rdataset_t *nameservers = NULL;
unsigned int options;
uint32_t tid = isc_tid();
REQUIRE(DNS_ADBNAME_VALID(adbname));
@ -3143,8 +3111,8 @@ fetch_name(dns_adbname_t *adbname, bool start_at_zone, unsigned int depth,
*/
result = dns_resolver_createfetch(
adb->res, &adbname->name, type, name, nameservers, NULL, NULL,
0, options, depth, qc, adb->tasks[tid], fetch_callback, adbname,
&fetch->rdataset, NULL, &fetch->fetch);
0, options, depth, qc, isc_loop_current(adb->loopmgr),
fetch_callback, adbname, &fetch->rdataset, NULL, &fetch->fetch);
if (result != ISC_R_SUCCESS) {
DP(ENTER_LEVEL, "fetch_name: createfetch failed with %s",
isc_result_totext(result));

70
lib/dns/client.c
View file

@ -25,7 +25,6 @@
#include <isc/result.h>
#include <isc/safe.h>
#include <isc/sockaddr.h>
#include <isc/task.h>
#include <isc/util.h>
#include <dns/adb.h>
@ -76,7 +75,6 @@ struct dns_client {
unsigned int magic;
unsigned int attributes;
isc_mem_t *mctx;
isc_task_t *task;
isc_loop_t *loop;
isc_nm_t *nm;
dns_dispatchmgr_t *dispatchmgr;
@ -135,7 +133,7 @@ typedef struct resarg {
} resarg_t;
static void
client_resfind(resctx_t *rctx, dns_fetchevent_t *event);
client_resfind(resctx_t *rctx, dns_fetchresponse_t *event);
static void
destroyrestrans(dns_clientrestrans_t **transp);
@ -203,8 +201,7 @@ getudpdispatch(int family, dns_dispatchmgr_t *dispatchmgr,
static isc_result_t
createview(isc_mem_t *mctx, dns_rdataclass_t rdclass, isc_loopmgr_t *loopmgr,
isc_taskmgr_t *taskmgr, isc_nm_t *nm,
isc_tlsctx_cache_t *tlsctx_client_cache,
isc_nm_t *nm, isc_tlsctx_cache_t *tlsctx_client_cache,
dns_dispatchmgr_t *dispatchmgr, dns_dispatch_t *dispatchv4,
dns_dispatch_t *dispatchv6, dns_view_t **viewp) {
isc_result_t result;
@ -221,7 +218,7 @@ createview(isc_mem_t *mctx, dns_rdataclass_t rdclass, isc_loopmgr_t *loopmgr,
goto cleanup_view;
}
result = dns_view_createresolver(view, loopmgr, taskmgr, 1, nm, 0,
result = dns_view_createresolver(view, loopmgr, 1, nm, 0,
tlsctx_client_cache, dispatchmgr,
dispatchv4, dispatchv6);
if (result != ISC_R_SUCCESS) {
@ -243,9 +240,8 @@ cleanup_view:
}
isc_result_t
dns_client_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
isc_taskmgr_t *taskmgr, isc_nm_t *nm, unsigned int options,
isc_tlsctx_cache_t *tlsctx_client_cache,
dns_client_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, isc_nm_t *nm,
unsigned int options, isc_tlsctx_cache_t *tlsctx_client_cache,
dns_client_t **clientp, const isc_sockaddr_t *localaddr4,
const isc_sockaddr_t *localaddr6) {
isc_result_t result;
@ -255,7 +251,6 @@ dns_client_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
dns_view_t *view = NULL;
REQUIRE(mctx != NULL);
REQUIRE(taskmgr != NULL);
REQUIRE(nm != NULL);
REQUIRE(tlsctx_client_cache != NULL);
REQUIRE(clientp != NULL && *clientp == NULL);
@ -268,14 +263,9 @@ dns_client_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
.nm = nm,
};
result = isc_task_create(taskmgr, &client->task, 0);
if (result != ISC_R_SUCCESS) {
goto cleanup_lock;
}
result = dns_dispatchmgr_create(mctx, nm, &client->dispatchmgr);
if (result != ISC_R_SUCCESS) {
goto cleanup_task;
goto cleanup_client;
}
(void)setsourceports(mctx, client->dispatchmgr);
@ -310,7 +300,7 @@ dns_client_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
isc_refcount_init(&client->references, 1);
/* Create the default view for class IN */
result = createview(mctx, dns_rdataclass_in, loopmgr, taskmgr, nm,
result = createview(mctx, dns_rdataclass_in, loopmgr, nm,
tlsctx_client_cache, client->dispatchmgr,
dispatchv4, dispatchv6, &view);
if (result != ISC_R_SUCCESS) {
@ -345,9 +335,7 @@ cleanup_dispatchmgr:
dns_dispatch_detach(&dispatchv6);
}
dns_dispatchmgr_detach(&client->dispatchmgr);
cleanup_task:
isc_task_detach(&client->task);
cleanup_lock:
cleanup_client:
isc_mem_put(mctx, client, sizeof(*client));
return (result);
@ -368,8 +356,6 @@ destroyclient(dns_client_t *client) {
dns_dispatchmgr_detach(&client->dispatchmgr);
isc_task_detach(&client->task);
client->magic = 0;
isc_mem_putanddetach(&client->mctx, client, sizeof(*client));
@ -459,15 +445,13 @@ putrdataset(isc_mem_t *mctx, dns_rdataset_t **rdatasetp) {
}
static void
fetch_done(isc_task_t *task, isc_event_t *event) {
resctx_t *rctx = event->ev_arg;
dns_fetchevent_t *fevent;
fetch_done(void *arg) {
dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg;
resctx_t *rctx = resp->arg;
REQUIRE(RCTX_VALID(rctx));
REQUIRE(rctx->client->task == task);
fevent = (dns_fetchevent_t *)event;
client_resfind(rctx, fevent);
client_resfind(rctx, resp);
}
static isc_result_t
@ -494,7 +478,7 @@ start_fetch(resctx_t *rctx) {
result = dns_resolver_createfetch(
rctx->view->resolver, dns_fixedname_name(&rctx->name),
rctx->type, NULL, NULL, NULL, NULL, 0, fopts, 0, NULL,
rctx->client->task, fetch_done, rctx, rctx->rdataset,
rctx->client->loop, fetch_done, rctx, rctx->rdataset,
rctx->sigrdataset, &rctx->fetch);
return (result);
@ -521,8 +505,8 @@ view_find(resctx_t *rctx, dns_db_t **dbp, dns_dbnode_t **nodep,
}
static void
client_resfind(resctx_t *rctx, dns_fetchevent_t *event) {
isc_mem_t *mctx;
client_resfind(resctx_t *rctx, dns_fetchresponse_t *resp) {
isc_mem_t *mctx = NULL;
isc_result_t tresult, result = ISC_R_SUCCESS;
isc_result_t vresult = ISC_R_SUCCESS;
bool want_restart;
@ -552,7 +536,7 @@ client_resfind(resctx_t *rctx, dns_fetchevent_t *event) {
rctx->restarts++;
want_restart = false;
if (event == NULL) {
if (resp == NULL) {
fname = dns_fixedname_initname(&foundname);
INSIST(!dns_rdataset_isassociated(rctx->rdataset));
INSIST(rctx->sigrdataset == NULL ||
@ -582,16 +566,17 @@ client_resfind(resctx_t *rctx, dns_fetchevent_t *event) {
goto done;
}
} else {
INSIST(event != NULL);
INSIST(event->fetch == rctx->fetch);
INSIST(resp != NULL);
INSIST(resp->fetch == rctx->fetch);
dns_resolver_destroyfetch(&rctx->fetch);
db = event->db;
node = event->node;
result = event->result;
vresult = event->vresult;
fname = event->foundname;
INSIST(event->rdataset == rctx->rdataset);
INSIST(event->sigrdataset == rctx->sigrdataset);
db = resp->db;
node = resp->node;
result = resp->result;
vresult = resp->vresult;
fname = resp->foundname;
INSIST(resp->rdataset == rctx->rdataset);
INSIST(resp->sigrdataset == rctx->sigrdataset);
isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp));
}
/*
@ -821,9 +806,6 @@ client_resfind(resctx_t *rctx, dns_fetchevent_t *event) {
if (db != NULL) {
dns_db_detach(&db);
}
if (event != NULL) {
isc_event_free(ISC_EVENT_PTR(&event));
}
/*
* Limit the number of restarts.

4
lib/dns/include/dns/adb.h
View file

@ -251,7 +251,7 @@ struct dns_adbaddrinfo {
isc_result_t
dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_loopmgr_t *loopmgr,
isc_taskmgr_t *taskmgr, dns_adb_t **newadb);
dns_adb_t **newadb);
/*%<
* Create a new ADB.
*
@ -266,7 +266,7 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_loopmgr_t *loopmgr,
*
*\li 'view' be a pointer to a valid view.
*
*\li 'taskmgr' be a pointer to a valid task manager.
*\li 'loopmgr' be a valid loop manager.
*
*\li 'newadb' != NULL && '*newadb' == NULL.
*

8
lib/dns/include/dns/client.h
View file

@ -42,6 +42,7 @@
#include <isc/event.h>
#include <isc/loop.h>
#include <isc/sockaddr.h>
#include <isc/tls.h>
#include <dns/tsig.h>
#include <dns/types.h>
@ -97,9 +98,8 @@ typedef struct dns_clientresume {
} dns_clientresume_t; /* too long? */
isc_result_t
dns_client_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
isc_taskmgr_t *taskmgr, isc_nm_t *nm, unsigned int options,
isc_tlsctx_cache_t *tlsctx_client_cache,
dns_client_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, isc_nm_t *nm,
unsigned int options, isc_tlsctx_cache_t *tlsctx_client_cache,
dns_client_t **clientp, const isc_sockaddr_t *localaddr4,
const isc_sockaddr_t *localaddr6);
/*%<
@ -120,8 +120,6 @@ dns_client_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
*
*\li 'loopmgr' is a valid loop manager.
*\li 'taskmgr' is a valid task manager.
*
*\li 'nm' is a valid network manager.
*
*\li 'tlsctx_client_cache' is a valid TLS context cache.

5
lib/dns/include/dns/nta.h
View file

@ -33,7 +33,6 @@
#include <isc/refcount.h>
#include <isc/rwlock.h>
#include <isc/stdtime.h>
#include <isc/task.h>
#include <isc/timer.h>
#include <dns/rdataset.h>
@ -47,8 +46,8 @@ ISC_LANG_BEGINDECLS
#define VALID_NTATABLE(nt) ISC_MAGIC_VALID(nt, NTATABLE_MAGIC)
isc_result_t
dns_ntatable_create(dns_view_t *view, isc_taskmgr_t *taskmgr,
isc_loopmgr_t *loopmgr, dns_ntatable_t **ntatablep);
dns_ntatable_create(dns_view_t *view, isc_loopmgr_t *loopmgr,
dns_ntatable_t **ntatablep);
/*%<
* Create an NTA table in view 'view'.
*

44
lib/dns/include/dns/resolver.h
View file

@ -48,8 +48,8 @@
#include <inttypes.h>
#include <stdbool.h>
#include <isc/event.h>
#include <isc/lang.h>
#include <isc/loop.h>
#include <isc/refcount.h>
#include <isc/stats.h>
#include <isc/tls.h>
@ -65,18 +65,23 @@
ISC_LANG_BEGINDECLS
/*%
* A dns_fetchevent_t is sent when a 'fetch' completes. Any of 'db',
* 'node', 'rdataset', and 'sigrdataset' may be bound. It is the
* receiver's responsibility to detach before freeing the event.
* A dns_fetchresponse_t is sent to the caller when a fetch completes.
* Any of 'db', 'node', 'rdataset', and 'sigrdataset' may be bound; it
* is the receiver's responsibility to detach them, and also free the
* structure.
*
* \brief
* 'rdataset', 'sigrdataset', 'client' and 'id' are the values that were
* supplied when dns_resolver_createfetch() was called. They are returned
* to the caller so that they may be freed.
*/
typedef struct dns_fetchevent {
ISC_EVENT_COMMON(struct dns_fetchevent);
typedef struct dns_fetchresponse dns_fetchresponse_t;
struct dns_fetchresponse {
dns_fetch_t *fetch;
isc_mem_t *mctx;
isc_result_t result;
isc_result_t vresult;
dns_rdatatype_t qtype;
dns_db_t *db;
dns_dbnode_t *node;
@ -86,8 +91,12 @@ typedef struct dns_fetchevent {
dns_name_t *foundname;
const isc_sockaddr_t *client;
dns_messageid_t id;
isc_result_t vresult;
} dns_fetchevent_t;
isc_loop_t *loop;
isc_job_cb cb;
void *arg;
enum { FETCHDONE, TRYSTALE } type;
ISC_LINK(dns_fetchresponse_t) link;
};
/*%
* The two quota types (fetches-per-zone and fetches-per-server)
@ -172,8 +181,8 @@ typedef enum { dns_quotatype_zone = 0, dns_quotatype_server } dns_quotatype_t;
isc_result_t
dns_resolver_create(dns_view_t *view, isc_loopmgr_t *loopmgr,
isc_taskmgr_t *taskmgr, unsigned int ndisp, isc_nm_t *nm,
unsigned int options, isc_tlsctx_cache_t *tlsctx_cache,
unsigned int ndisp, isc_nm_t *nm, unsigned int options,
isc_tlsctx_cache_t *tlsctx_cache,
dns_dispatchmgr_t *dispatchmgr, dns_dispatch_t *dispatchv4,
dns_dispatch_t *dispatchv6, dns_resolver_t **resp);
@ -189,9 +198,7 @@ dns_resolver_create(dns_view_t *view, isc_loopmgr_t *loopmgr,
*
*\li 'view' is a valid view.
*
*\li 'taskmgr' is a valid task manager.
*
*\li 'ntasks' > 0.
*\li 'ndisp' > 0.
*
*\li 'nm' is a valid network manager.
*
@ -285,10 +292,9 @@ dns_resolver_createfetch(dns_resolver_t *res, const dns_name_t *name,
dns_forwarders_t *forwarders,
const isc_sockaddr_t *client, dns_messageid_t id,
unsigned int options, unsigned int depth,
isc_counter_t *qc, isc_task_t *task,
isc_taskaction_t action, void *arg,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
dns_fetch_t **fetchp);
isc_counter_t *qc, isc_loop_t *loop, isc_job_cb cb,
void *arg, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset, dns_fetch_t **fetchp);
/*%<
* Recurse to answer a question.
*
@ -305,8 +311,8 @@ dns_resolver_createfetch(dns_resolver_t *res, const dns_name_t *name,
* we figure out how selective forwarding will work.
*
*\li When the fetch completes (successfully or otherwise), a
* #DNS_EVENT_FETCHDONE event with action 'action' and arg 'arg' will be
* posted to 'task'.
* dns_fetchresponse_t option is sent to callback 'cb' with
* 'type' set to FETCHDONE.
*
*\li The values of 'rdataset' and 'sigrdataset' will be returned in
* the FETCHDONE event.

5
lib/dns/include/dns/validator.h
View file

@ -135,7 +135,6 @@ struct dns_validator {
dns_keytable_t *keytable;
dst_key_t *key;
dns_rdata_rrsig_t *siginfo;
isc_task_t *task;
isc_loop_t *loop;
isc_job_cb cb;
void *arg;
@ -171,8 +170,8 @@ isc_result_t
dns_validator_create(dns_view_t *view, dns_name_t *name, dns_rdatatype_t type,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
dns_message_t *message, unsigned int options,
isc_task_t *task, isc_loop_t *loop, isc_job_cb cb,
void *arg, dns_validator_t **validatorp);
isc_loop_t *loop, isc_job_cb cb, void *arg,
dns_validator_t **validatorp);
/*%<
* Start a DNSSEC validation.
*

17
lib/dns/include/dns/view.h
View file

@ -104,7 +104,7 @@ struct dns_view {
isc_mutex_t lock;
bool frozen;
isc_task_t *task;
isc_loop_t *loop;
bool cacheshared;
/* Configurable data. */
@ -388,10 +388,9 @@ dns_view_createzonetable(dns_view_t *view);
isc_result_t
dns_view_createresolver(dns_view_t *view, isc_loopmgr_t *loopmgr,
isc_taskmgr_t *taskmgr, unsigned int ndisp,
isc_nm_t *netmgr, unsigned int options,
isc_tlsctx_cache_t *tlsctx_cache,
dns_dispatchmgr_t *dispatchmgr,
unsigned int ndisp, isc_nm_t *netmgr,
unsigned int options, isc_tlsctx_cache_t *tlsctx_cache,
dns_dispatchmgr_t *dispatchmgr,
dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6);
/*%<
* Create a resolver and address database for the view.
@ -402,9 +401,8 @@ dns_view_createresolver(dns_view_t *view, isc_loopmgr_t *loopmgr,
*
*\li 'view' does not have a resolver already.
*
*\li The requirements of dns_resolver_create() apply to 'taskmgr',
* 'ndisp', 'netmgr', 'options', 'tlsctx_cache', 'dispatchv4', and
* 'dispatchv6'.
*\li The requirements of dns_resolver_create() apply to 'ndisp',
* 'netmgr', 'options', 'tlsctx_cache', 'dispatchv4', and 'dispatchv6'.
*
* Returns:
*
@ -1008,8 +1006,7 @@ dns_view_iscacheshared(dns_view_t *view);
*/
isc_result_t
dns_view_initntatable(dns_view_t *view, isc_taskmgr_t *taskmgr,
isc_loopmgr_t *loopmgr);
dns_view_initntatable(dns_view_t *view, isc_loopmgr_t *loopmgr);
/*%<
* Initialize the negative trust anchor table for the view.
*

49
lib/dns/nta.c
View file

@ -47,7 +47,6 @@ struct dns_ntatable {
dns_view_t *view;
isc_rwlock_t rwlock;
isc_loopmgr_t *loopmgr;
isc_task_t *task;
/* Protected by atomics */
isc_refcount_t references;
/* Locked by rwlock. */
@ -92,6 +91,7 @@ dns__nta_destroy(dns__nta_t *nta) {
dns_resolver_cancelfetch(nta->fetch);
dns_resolver_destroyfetch(&nta->fetch);
}
isc_loop_detach(&nta->loop);
isc_mem_putanddetach(&nta->mctx, nta, sizeof(*nta));
}
@ -108,8 +108,8 @@ dns__nta_free(void *data, void *arg) {
}
isc_result_t
dns_ntatable_create(dns_view_t *view, isc_taskmgr_t *taskmgr,
isc_loopmgr_t *loopmgr, dns_ntatable_t **ntatablep) {
dns_ntatable_create(dns_view_t *view, isc_loopmgr_t *loopmgr,
dns_ntatable_t **ntatablep) {
dns_ntatable_t *ntatable;
isc_result_t result;
@ -123,16 +123,10 @@ dns_ntatable_create(dns_view_t *view, isc_taskmgr_t *taskmgr,
isc_mem_attach(view->mctx, &ntatable->mctx);
dns_view_weakattach(view, &ntatable->view);
result = isc_task_create(taskmgr, &ntatable->task, 0);
if (result != ISC_R_SUCCESS) {
goto cleanup_ntatable;
}
isc_task_setname(ntatable->task, "ntatable", ntatable);
result = dns_rbt_create(ntatable->mctx, dns__nta_free, NULL,
&ntatable->table);
if (result != ISC_R_SUCCESS) {
goto cleanup_task;
goto cleanup;
}
isc_rwlock_init(&ntatable->rwlock);
@ -144,10 +138,7 @@ dns_ntatable_create(dns_view_t *view, isc_taskmgr_t *taskmgr,
return (ISC_R_SUCCESS);
cleanup_task:
isc_task_detach(&ntatable->task);
cleanup_ntatable:
cleanup:
isc_mem_putanddetach(&ntatable->mctx, ntatable, sizeof(*ntatable));
return (result);
@ -159,7 +150,6 @@ dns__ntatable_destroy(dns_ntatable_t *ntatable) {
ntatable->magic = 0;
dns_rbt_destroy(&ntatable->table);
isc_rwlock_destroy(&ntatable->rwlock);
isc_task_detach(&ntatable->task);
INSIST(ntatable->view == NULL);
isc_mem_putanddetach(&ntatable->mctx, ntatable, sizeof(*ntatable));
}
@ -167,35 +157,33 @@ dns__ntatable_destroy(dns_ntatable_t *ntatable) {
ISC_REFCOUNT_IMPL(dns_ntatable, dns__ntatable_destroy);
static void
fetch_done(isc_task_t *task, isc_event_t *event) {
dns_fetchevent_t *devent = (dns_fetchevent_t *)event;
dns__nta_t *nta = devent->ev_arg;
isc_result_t eresult = devent->result;
fetch_done(void *arg) {
dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg;
dns__nta_t *nta = resp->arg;
isc_result_t eresult = resp->result;
dns_ntatable_t *ntatable = nta->ntatable;
dns_view_t *view = ntatable->view;
isc_stdtime_t now;
UNUSED(task);
if (dns_rdataset_isassociated(&nta->rdataset)) {
dns_rdataset_disassociate(&nta->rdataset);
}
if (dns_rdataset_isassociated(&nta->sigrdataset)) {
dns_rdataset_disassociate(&nta->sigrdataset);
}
if (nta->fetch == devent->fetch) {
if (nta->fetch == resp->fetch) {
nta->fetch = NULL;
}
dns_resolver_destroyfetch(&devent->fetch);
dns_resolver_destroyfetch(&resp->fetch);
if (devent->node != NULL) {
dns_db_detachnode(devent->db, &devent->node);
if (resp->node != NULL) {
dns_db_detachnode(resp->db, &resp->node);
}
if (devent->db != NULL) {
dns_db_detach(&devent->db);
if (resp->db != NULL) {
dns_db_detach(&resp->db);
}
isc_event_free(&event);
isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp));
isc_stdtime_get(&now);
switch (eresult) {
@ -258,7 +246,7 @@ checkbogus(void *arg) {
dns__nta_ref(nta); /* for dns_resolver_createfetch */
result = dns_resolver_createfetch(
resolver, nta->name, dns_rdatatype_nsec, NULL, NULL, NULL, NULL,
0, DNS_FETCHOPT_NONTA, 0, NULL, ntatable->task, fetch_done, nta,
0, DNS_FETCHOPT_NONTA, 0, NULL, nta->loop, fetch_done, nta,
&nta->rdataset, &nta->sigrdataset, &nta->fetch);
if (result != ISC_R_SUCCESS) {
dns__nta_detach(&nta); /* for dns_resolver_createfetch() */
@ -295,11 +283,10 @@ nta_create(dns_ntatable_t *ntatable, const dns_name_t *name,
nta = isc_mem_get(ntatable->mctx, sizeof(dns__nta_t));
*nta = (dns__nta_t){
.ntatable = ntatable,
.loop = isc_loop_current(ntatable->loopmgr),
.magic = NTA_MAGIC,
};
isc_mem_attach(ntatable->mctx, &nta->mctx);
isc_loop_attach(isc_loop_current(ntatable->loopmgr), &nta->loop);
dns_rdataset_init(&nta->rdataset);
dns_rdataset_init(&nta->sigrdataset);

602
lib/dns/resolver.c
View file

File diff suppressed because it is too large Load diff

82
lib/dns/validator.c
View file

@ -20,7 +20,6 @@
#include <isc/mem.h>
#include <isc/result.h>
#include <isc/string.h>
#include <isc/task.h>
#include <isc/util.h>
#include <dns/client.h>
@ -207,7 +206,7 @@ marksecure(dns_valstatus_t *vstat) {
}
/*
* Validator 'val' is finished; send the completion event to the task
* Validator 'val' is finished; send the completion event to the loop
* that called dns_validator_create(), with result `result`.
*
* Caller must be holding the validator lock.
@ -367,34 +366,29 @@ trynsec3:
* If not found, fail the validation process.
*/
static void
fetch_callback_dnskey(isc_task_t *task, isc_event_t *event) {
dns_fetchevent_t *devent;
dns_validator_t *val;
dns_rdataset_t *rdataset;
bool want_destroy;
fetch_callback_dnskey(void *arg) {
dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg;
dns_validator_t *val = resp->arg;
dns_rdataset_t *rdataset = &val->frdataset;
isc_result_t eresult = resp->result;
isc_result_t result;
isc_result_t eresult;
isc_result_t saved_result;
dns_fetch_t *fetch;
dns_fetch_t *fetch = NULL;
bool want_destroy;
UNUSED(task);
INSIST(event->ev_type == DNS_EVENT_FETCHDONE);
devent = (dns_fetchevent_t *)event;
val = devent->ev_arg;
rdataset = &val->frdataset;
eresult = devent->result;
INSIST(resp->type == FETCHDONE);
/* Free resources which are not of interest. */
if (devent->node != NULL) {
dns_db_detachnode(devent->db, &devent->node);
if (resp->node != NULL) {
dns_db_detachnode(resp->db, &resp->node);
}
if (devent->db != NULL) {
dns_db_detach(&devent->db);
if (resp->db != NULL) {
dns_db_detach(&resp->db);
}
if (dns_rdataset_isassociated(&val->fsigrdataset)) {
dns_rdataset_disassociate(&val->fsigrdataset);
}
isc_event_free(&event);
isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp));
INSIST(val->vstat != NULL);
@ -467,21 +461,16 @@ fetch_callback_dnskey(isc_task_t *task, isc_event_t *event) {
* walking a trust chain, or an insecurity proof.
*/
static void
fetch_callback_ds(isc_task_t *task, isc_event_t *event) {
dns_fetchevent_t *devent;
dns_validator_t *val;
dns_rdataset_t *rdataset;
bool want_destroy, trustchain;
fetch_callback_ds(void *arg) {
dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg;
dns_validator_t *val = resp->arg;
dns_rdataset_t *rdataset = &val->frdataset;
isc_result_t eresult = resp->result;
isc_result_t result;
isc_result_t eresult;
dns_fetch_t *fetch;
dns_fetch_t *fetch = NULL;
bool want_destroy, trustchain;
UNUSED(task);
INSIST(event->ev_type == DNS_EVENT_FETCHDONE);
devent = (dns_fetchevent_t *)event;
val = devent->ev_arg;
rdataset = &val->frdataset;
eresult = devent->result;
INSIST(resp->type == FETCHDONE);
/*
* Set 'trustchain' to true if we're walking a chain of
@ -490,11 +479,11 @@ fetch_callback_ds(isc_task_t *task, isc_event_t *event) {
trustchain = ((val->attributes & VALATTR_INSECURITY) == 0);
/* Free resources which are not of interest. */
if (devent->node != NULL) {
dns_db_detachnode(devent->db, &devent->node);
if (resp->node != NULL) {
dns_db_detachnode(resp->db, &resp->node);
}
if (devent->db != NULL) {
dns_db_detach(&devent->db);
if (resp->db != NULL) {
dns_db_detach(&resp->db);
}
if (dns_rdataset_isassociated(&val->fsigrdataset)) {
dns_rdataset_disassociate(&val->fsigrdataset);
@ -572,7 +561,7 @@ fetch_callback_ds(isc_task_t *task, isc_event_t *event) {
} else if (eresult == DNS_R_SERVFAIL) {
goto unexpected;
} else if (eresult != DNS_R_CNAME &&
isdelegation(devent->foundname, &val->frdataset,
isdelegation(resp->foundname, &val->frdataset,
eresult))
{
/*
@ -608,7 +597,7 @@ fetch_callback_ds(isc_task_t *task, isc_event_t *event) {
}
done:
isc_event_free(&event);
isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp));
want_destroy = exit_check(val);
UNLOCK(&val->lock);
@ -996,7 +985,7 @@ check_deadlock(dns_validator_t *val, dns_name_t *name, dns_rdatatype_t type,
*/
static isc_result_t
create_fetch(dns_validator_t *val, dns_name_t *name, dns_rdatatype_t type,
isc_taskaction_t callback, const char *caller) {
isc_job_cb callback, const char *caller) {
unsigned int fopts = 0;
disassociate_rdatasets(val);
@ -1018,7 +1007,7 @@ create_fetch(dns_validator_t *val, dns_name_t *name, dns_rdatatype_t type,
validator_logcreate(val, name, type, caller, "fetch");
return (dns_resolver_createfetch(
val->view->resolver, name, type, NULL, NULL, NULL, NULL, 0,
fopts, 0, NULL, val->task, callback, val, &val->frdataset,
fopts, 0, NULL, val->loop, callback, val, &val->frdataset,
&val->fsigrdataset, &val->fetch));
}
@ -1049,8 +1038,8 @@ create_validator(dns_validator_t *val, dns_name_t *name, dns_rdatatype_t type,
validator_logcreate(val, name, type, caller, "validator");
result = dns_validator_create(val->view, name, type, rdataset, sig,
NULL, vopts, val->task, val->loop, cb,
val, &val->subvalidator);
NULL, vopts, val->loop, cb, val,
&val->subvalidator);
if (result == ISC_R_SUCCESS) {
val->subvalidator->parent = val;
val->subvalidator->depth = val->depth + 1;
@ -3074,8 +3063,8 @@ isc_result_t
dns_validator_create(dns_view_t *view, dns_name_t *name, dns_rdatatype_t type,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
dns_message_t *message, unsigned int options,
isc_task_t *task, isc_loop_t *loop, isc_job_cb cb,
void *arg, dns_validator_t **validatorp) {
isc_loop_t *loop, isc_job_cb cb, void *arg,
dns_validator_t **validatorp) {
isc_result_t result = ISC_R_FAILURE;
dns_validator_t *val = NULL;
dns_valstatus_t *vstat = NULL;
@ -3105,7 +3094,6 @@ dns_validator_create(dns_view_t *view, dns_name_t *name, dns_rdatatype_t type,
.loop = loop,
.cb = cb,
.arg = arg };
isc_task_attach(task, &val->task);
dns_view_attach(view, &val->view);
isc_mutex_init(&val->lock);
@ -3135,7 +3123,6 @@ dns_validator_create(dns_view_t *view, dns_name_t *name, dns_rdatatype_t type,
cleanup:
isc_mutex_destroy(&val->lock);
isc_task_detach(&val->task);
isc_mem_putanddetach(&vstat->mctx, vstat, sizeof(*vstat));
dns_view_detach(&val->view);
@ -3206,7 +3193,6 @@ destroy(dns_validator_t *val) {
}
isc_mutex_destroy(&val->lock);
dns_view_detach(&val->view);
isc_task_detach(&val->task);
if (val->vstat->message != NULL) {
dns_message_detach(&val->vstat->message);
}

29
lib/dns/view.c
View file

@ -319,9 +319,6 @@ destroy(dns_view_t *view) {
if (view->requestmgr != NULL) {
dns_requestmgr_detach(&view->requestmgr);
}
if (view->task != NULL) {
isc_task_detach(&view->task);
}
if (view->hints != NULL) {
dns_db_detach(&view->hints);
}
@ -640,9 +637,8 @@ dns_view_createzonetable(dns_view_t *view) {
isc_result_t
dns_view_createresolver(dns_view_t *view, isc_loopmgr_t *loopmgr,
isc_taskmgr_t *taskmgr, unsigned int ndisp,
isc_nm_t *netmgr, unsigned int options,
isc_tlsctx_cache_t *tlsctx_cache,
unsigned int ndisp, isc_nm_t *netmgr,
unsigned int options, isc_tlsctx_cache_t *tlsctx_cache,
dns_dispatchmgr_t *dispatchmgr,
dns_dispatch_t *dispatchv4,
dns_dispatch_t *dispatchv6) {
@ -653,23 +649,18 @@ dns_view_createresolver(dns_view_t *view, isc_loopmgr_t *loopmgr,
REQUIRE(!view->frozen);
REQUIRE(view->resolver == NULL);
result = isc_task_create(taskmgr, &view->task, 0);
if (result != ISC_R_SUCCESS) {
return (result);
}
isc_task_setname(view->task, "view", view);
view->loop = isc_loop_current(loopmgr);
result = dns_resolver_create(view, loopmgr, taskmgr, ndisp, netmgr,
options, tlsctx_cache, dispatchmgr,
dispatchv4, dispatchv6, &view->resolver);
result = dns_resolver_create(view, loopmgr, ndisp, netmgr, options,
tlsctx_cache, dispatchmgr, dispatchv4,
dispatchv6, &view->resolver);
if (result != ISC_R_SUCCESS) {
isc_task_detach(&view->task);
return (result);
}
isc_mem_create(&mctx);
isc_mem_setname(mctx, "ADB");
result = dns_adb_create(mctx, view, loopmgr, taskmgr, &view->adb);
result = dns_adb_create(mctx, view, loopmgr, &view->adb);
isc_mem_detach(&mctx);
if (result != ISC_R_SUCCESS) {
goto cleanup_resolver;
@ -1691,14 +1682,12 @@ dns_view_freezezones(dns_view_t *view, bool value) {
}
isc_result_t
dns_view_initntatable(dns_view_t *view, isc_taskmgr_t *taskmgr,
isc_loopmgr_t *loopmgr) {
dns_view_initntatable(dns_view_t *view, isc_loopmgr_t *loopmgr) {
REQUIRE(DNS_VIEW_VALID(view));
if (view->ntatable_priv != NULL) {
dns_ntatable_detach(&view->ntatable_priv);
}
return (dns_ntatable_create(view, taskmgr, loopmgr,
&view->ntatable_priv));
return (dns_ntatable_create(view, loopmgr, &view->ntatable_priv));
}
isc_result_t

39
lib/dns/zone.c
View file

@ -9973,11 +9973,11 @@ revocable(dns_keyfetch_t *kfetch, dns_rdata_keydata_t *keydata) {
* local trust anchors according to RFC5011.
*/
static void
keyfetch_done(isc_task_t *task, isc_event_t *event) {
keyfetch_done(void *arg) {
dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg;
isc_result_t result, eresult;
dns_fetchevent_t *devent;
dns_keyfetch_t *kfetch;
dns_zone_t *zone;
dns_keyfetch_t *kfetch = NULL;
dns_zone_t *zone = NULL;
isc_mem_t *mctx = NULL;
dns_keytable_t *secroots = NULL;
dns_dbversion_t *ver = NULL;
@ -10004,11 +10004,12 @@ keyfetch_done(isc_task_t *task, isc_event_t *event) {
dns_rdataset_t *dnskeys = NULL, *dnskeysigs = NULL;
dns_rdataset_t *keydataset = NULL, dsset;
UNUSED(task);
INSIST(event != NULL && event->ev_type == DNS_EVENT_FETCHDONE);
INSIST(event->ev_arg != NULL);
INSIST(resp != NULL && resp->type == FETCHDONE);
kfetch = resp->arg;
INSIST(kfetch != NULL);
kfetch = event->ev_arg;
zone = kfetch->zone;
mctx = kfetch->mctx;
keyname = dns_fixedname_name(&kfetch->name);
@ -10016,17 +10017,16 @@ keyfetch_done(isc_task_t *task, isc_event_t *event) {
dnskeysigs = &kfetch->dnskeysigset;
keydataset = &kfetch->keydataset;
devent = (dns_fetchevent_t *)event;
eresult = devent->result;
eresult = resp->result;
/* Free resources which are not of interest */
if (devent->node != NULL) {
dns_db_detachnode(devent->db, &devent->node);
if (resp->node != NULL) {
dns_db_detachnode(resp->db, &resp->node);
}
if (devent->db != NULL) {
dns_db_detach(&devent->db);
if (resp->db != NULL) {
dns_db_detach(&resp->db);
}
isc_event_free(&event);
dns_resolver_destroyfetch(&kfetch->fetch);
LOCK_ZONE(zone);
@ -10621,6 +10621,7 @@ cleanup:
dns_name_free(keyname, mctx);
isc_mem_putanddetach(&kfetch->mctx, kfetch, sizeof(dns_keyfetch_t));
isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp));
if (secroots != NULL) {
dns_keytable_detach(&secroots);
@ -10710,15 +10711,13 @@ do_keyfetch(void *arg) {
*/
result = dns_resolver_createfetch(
resolver, kname, dns_rdatatype_dnskey, NULL, NULL, NULL, NULL,
0, options, 0, NULL, zone->task, keyfetch_done, kfetch,
0, options, 0, NULL, zone->loop, keyfetch_done, kfetch,
&kfetch->dnskeyset, &kfetch->dnskeysigset, &kfetch->fetch);
dns_resolver_detach(&resolver);
if (result != ISC_R_SUCCESS) {
goto retry;
if (result == ISC_R_SUCCESS) {
return;
}
return;
retry:
retry_keyfetch(kfetch, kname);
}

2
lib/ns/include/ns/hooks.h
View file

@ -436,7 +436,7 @@ struct ns_hookasync {
/*
* isc_event to be sent on the completion of a hook-initiated asyncronous
* process, similar to dns_fetchevent_t.
* process, similar to dns_fetchresponse_t.
*/
typedef struct ns_hook_resume {
ns_hookasync_t *ctx; /* asynchronous processing context */

2
lib/ns/include/ns/query.h
View file

@ -220,7 +220,7 @@ struct query_ctx {
ns_client_t *client; /* client object */
bool detach_client; /* client needs detaching */
dns_fetchevent_t *event; /* recursion event */
dns_fetchresponse_t *fresp; /* recursion response */
dns_db_t *db; /* zone or cache database */
dns_dbversion_t *version; /* DB version */

192
lib/ns/query.c
View file

@ -394,8 +394,8 @@ static void
query_trace(query_ctx_t *qctx);
static void
qctx_init(ns_client_t *client, dns_fetchevent_t **eventp, dns_rdatatype_t qtype,
query_ctx_t *qctx);
qctx_init(ns_client_t *client, dns_fetchresponse_t **respp,
dns_rdatatype_t qtype, query_ctx_t *qctx);
static isc_result_t
qctx_prepare_buffers(query_ctx_t *qctx, isc_buffer_t *buffer);
@ -413,7 +413,7 @@ static isc_result_t
query_lookup(query_ctx_t *qctx);
static void
fetch_callback(isc_task_t *task, isc_event_t *event);
fetch_callback(void *arg);
static void
recparam_update(ns_query_recparam_t *param, dns_rdatatype_t qtype,
@ -2460,38 +2460,29 @@ fixfname(ns_client_t *client, dns_name_t **fname, isc_buffer_t **dbuf,
}
static void
free_devent(ns_client_t *client, isc_event_t **eventp,
dns_fetchevent_t **deventp) {
dns_fetchevent_t *devent = *deventp;
free_fresp(ns_client_t *client, dns_fetchresponse_t **frespp) {
dns_fetchresponse_t *fresp = *frespp;
REQUIRE((void *)(*eventp) == (void *)(*deventp));
CTRACE(ISC_LOG_DEBUG(3), "free_fresp");
CTRACE(ISC_LOG_DEBUG(3), "free_devent");
if (devent->fetch != NULL) {
dns_resolver_destroyfetch(&devent->fetch);
if (fresp->fetch != NULL) {
dns_resolver_destroyfetch(&fresp->fetch);
}
if (devent->node != NULL) {
dns_db_detachnode(devent->db, &devent->node);
if (fresp->node != NULL) {
dns_db_detachnode(fresp->db, &fresp->node);
}
if (devent->db != NULL) {
dns_db_detach(&devent->db);
if (fresp->db != NULL) {
dns_db_detach(&fresp->db);
}
if (devent->rdataset != NULL) {
ns_client_putrdataset(client, &devent->rdataset);
if (fresp->rdataset != NULL) {
ns_client_putrdataset(client, &fresp->rdataset);
}
if (devent->sigrdataset != NULL) {
ns_client_putrdataset(client, &devent->sigrdataset);
if (fresp->sigrdataset != NULL) {
ns_client_putrdataset(client, &fresp->sigrdataset);
}
/*
* If the two pointers are the same then leave the setting of
* (*deventp) to NULL to isc_event_free.
*/
if ((void *)eventp != (void *)deventp) {
(*deventp) = NULL;
}
isc_event_free(eventp);
*frespp = NULL;
isc_mem_putanddetach(&fresp->mctx, fresp, sizeof(*fresp));
}
static isc_result_t
@ -2630,30 +2621,25 @@ stale_refresh_aftermath(ns_client_t *client, isc_result_t result) {
}
static void
cleanup_after_fetch(isc_task_t *task, isc_event_t *event, const char *ctracestr,
cleanup_after_fetch(dns_fetchresponse_t *resp, const char *ctracestr,
ns_query_rectype_t recursion_type) {
dns_fetchevent_t *devent = (dns_fetchevent_t *)event;
isc_nmhandle_t **handlep;
dns_fetch_t **fetchp;
ns_client_t *client;
ns_client_t *client = resp->arg;
isc_nmhandle_t **handlep = NULL;
dns_fetch_t **fetchp = NULL;
isc_result_t result;
UNUSED(task);
REQUIRE(event->ev_type == DNS_EVENT_FETCHDONE);
client = devent->ev_arg;
REQUIRE(resp->type == FETCHDONE);
REQUIRE(NS_CLIENT_VALID(client));
REQUIRE(task == client->manager->task);
CTRACE(ISC_LOG_DEBUG(3), ctracestr);
handlep = &client->query.recursions[recursion_type].handle;
fetchp = &client->query.recursions[recursion_type].fetch;
result = devent->result;
result = resp->result;
LOCK(&client->query.fetchlock);
if (*fetchp != NULL) {
INSIST(devent->fetch == *fetchp);
INSIST(resp->fetch == *fetchp);
*fetchp = NULL;
}
UNLOCK(&client->query.fetchlock);
@ -2664,24 +2650,23 @@ cleanup_after_fetch(isc_task_t *task, isc_event_t *event, const char *ctracestr,
}
recursionquotatype_detach(client, recursion_type);
free_devent(client, &event, &devent);
free_fresp(client, &resp);
isc_nmhandle_detach(handlep);
}
static void
prefetch_done(isc_task_t *task, isc_event_t *event) {
cleanup_after_fetch(task, event, "prefetch_done", RECTYPE_PREFETCH);
prefetch_done(void *arg) {
cleanup_after_fetch(arg, "prefetch_done", RECTYPE_PREFETCH);
}
static void
rpzfetch_done(isc_task_t *task, isc_event_t *event) {
cleanup_after_fetch(task, event, "rpzfetch_done", RECTYPE_RPZ);
rpzfetch_done(void *arg) {
cleanup_after_fetch(arg, "rpzfetch_done", RECTYPE_RPZ);
}
static void
stale_refresh_done(isc_task_t *task, isc_event_t *event) {
cleanup_after_fetch(task, event, "stale_refresh_done",
RECTYPE_STALE_REFRESH);
stale_refresh_done(void *arg) {
cleanup_after_fetch(arg, "stale_refresh_done", RECTYPE_STALE_REFRESH);
}
/*
@ -2698,7 +2683,7 @@ fetch_and_forget(ns_client_t *client, dns_name_t *qname, dns_rdatatype_t qtype,
dns_rdataset_t *tmprdataset;
isc_sockaddr_t *peeraddr;
unsigned int options;
isc_taskaction_t action;
isc_job_cb cb;
isc_nmhandle_t **handlep;
dns_fetch_t **fetchp;
isc_result_t result;
@ -2719,15 +2704,15 @@ fetch_and_forget(ns_client_t *client, dns_name_t *qname, dns_rdatatype_t qtype,
switch (recursion_type) {
case RECTYPE_PREFETCH:
options = client->query.fetchoptions | DNS_FETCHOPT_PREFETCH;
action = prefetch_done;
cb = prefetch_done;
break;
case RECTYPE_RPZ:
options = client->query.fetchoptions;
action = rpzfetch_done;
cb = rpzfetch_done;
break;
case RECTYPE_STALE_REFRESH:
options = client->query.fetchoptions;
action = stale_refresh_done;
cb = stale_refresh_done;
break;
default:
UNREACHABLE();
@ -2737,11 +2722,10 @@ fetch_and_forget(ns_client_t *client, dns_name_t *qname, dns_rdatatype_t qtype,
fetchp = &client->query.recursions[recursion_type].fetch;
isc_nmhandle_attach(client->handle, handlep);
result = dns_resolver_createfetch(client->view->resolver, qname, qtype,
NULL, NULL, NULL, peeraddr,
client->message->id, options, 0, NULL,
client->manager->task, action, client,
tmprdataset, NULL, fetchp);
result = dns_resolver_createfetch(
client->view->resolver, qname, qtype, NULL, NULL, NULL,
peeraddr, client->message->id, options, 0, NULL,
client->manager->loop, cb, client, tmprdataset, NULL, fetchp);
if (result != ISC_R_SUCCESS) {
ns_client_putrdataset(client, &tmprdataset);
isc_nmhandle_detach(handlep);
@ -5335,8 +5319,8 @@ nxrrset:
* when leaving the scope or freeing the qctx.
*/
static void
qctx_init(ns_client_t *client, dns_fetchevent_t **eventp, dns_rdatatype_t qtype,
query_ctx_t *qctx) {
qctx_init(ns_client_t *client, dns_fetchresponse_t **frespp,
dns_rdatatype_t qtype, query_ctx_t *qctx) {
REQUIRE(qctx != NULL);
REQUIRE(client != NULL);
@ -5349,11 +5333,11 @@ qctx_init(ns_client_t *client, dns_fetchevent_t **eventp, dns_rdatatype_t qtype,
CCTRACE(ISC_LOG_DEBUG(3), "qctx_init");
if (eventp != NULL) {
qctx->event = *eventp;
*eventp = NULL;
if (frespp != NULL) {
qctx->fresp = *frespp;
*frespp = NULL;
} else {
qctx->event = NULL;
qctx->fresp = NULL;
}
qctx->qtype = qctx->type = qtype;
qctx->result = ISC_R_SUCCESS;
@ -5424,9 +5408,8 @@ qctx_freedata(query_ctx_t *qctx) {
dns_db_detach(&qctx->zdb);
}
if (qctx->event != NULL && !qctx->client->nodetach) {
free_devent(qctx->client, ISC_EVENT_PTR(&qctx->event),
&qctx->event);
if (qctx->fresp != NULL && !qctx->client->nodetach) {
free_fresp(qctx->client, &qctx->fresp);
}
}
@ -5465,7 +5448,7 @@ qctx_save(query_ctx_t *src, query_ctx_t *tgt) {
INITANDSAVE(tgt->rdataset, src->rdataset);
INITANDSAVE(tgt->sigrdataset, src->sigrdataset);
INITANDSAVE(tgt->noqname, src->noqname);
INITANDSAVE(tgt->event, src->event);
INITANDSAVE(tgt->fresp, src->fresp);
INITANDSAVE(tgt->db, src->db);
INITANDSAVE(tgt->version, src->version);
INITANDSAVE(tgt->node, src->node);
@ -5797,7 +5780,7 @@ ns__query_start(query_ctx_t *qctx) {
* Attach to the database which will be used to prepare the answer.
* Update query statistics.
*/
if (qctx->event == NULL && qctx->client->query.restarts == 0) {
if (qctx->fresp == NULL && qctx->client->query.restarts == 0) {
if (qctx->is_zone) {
if (qctx->zone != NULL) {
/*
@ -6236,10 +6219,10 @@ query_lookup_stale(ns_client_t *client) {
* call query_resume() to continue the ongoing work.
*/
static void
fetch_callback(isc_task_t *task, isc_event_t *event) {
dns_fetchevent_t *devent = (dns_fetchevent_t *)event;
fetch_callback(void *arg) {
dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg;
ns_client_t *client = resp->arg;
dns_fetch_t *fetch = NULL;
ns_client_t *client = NULL;
bool fetch_canceled = false;
bool fetch_answered = false;
isc_logcategory_t *logcategory = NS_LOGCATEGORY_QUERY_ERRORS;
@ -6247,24 +6230,16 @@ fetch_callback(isc_task_t *task, isc_event_t *event) {
int errorloglevel;
query_ctx_t qctx;
UNUSED(task);
REQUIRE(event->ev_type == DNS_EVENT_FETCHDONE ||
event->ev_type == DNS_EVENT_TRYSTALE);
client = devent->ev_arg;
REQUIRE(NS_CLIENT_VALID(client));
REQUIRE(task == client->manager->task);
REQUIRE(RECURSING(client));
CTRACE(ISC_LOG_DEBUG(3), "fetch_callback");
if (event->ev_type == DNS_EVENT_TRYSTALE) {
if (devent->result != ISC_R_CANCELED) {
if (resp->type == TRYSTALE) {
if (resp->result != ISC_R_CANCELED) {
query_lookup_stale(client);
}
isc_event_free(ISC_EVENT_PTR(&event));
isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp));
return;
}
/*
@ -6279,7 +6254,7 @@ fetch_callback(isc_task_t *task, isc_event_t *event) {
client->nodetach = false;
LOCK(&client->query.fetchlock);
INSIST(FETCH_RECTYPE_NORMAL(client) == devent->fetch ||
INSIST(FETCH_RECTYPE_NORMAL(client) == resp->fetch ||
FETCH_RECTYPE_NORMAL(client) == NULL);
if (QUERY_STALEPENDING(&client->query)) {
/*
@ -6293,7 +6268,7 @@ fetch_callback(isc_task_t *task, isc_event_t *event) {
/*
* This is the fetch we've been waiting for.
*/
INSIST(FETCH_RECTYPE_NORMAL(client) == devent->fetch);
INSIST(FETCH_RECTYPE_NORMAL(client) == resp->fetch);
FETCH_RECTYPE_NORMAL(client) = NULL;
/*
@ -6309,7 +6284,7 @@ fetch_callback(isc_task_t *task, isc_event_t *event) {
}
UNLOCK(&client->query.fetchlock);
SAVE(fetch, devent->fetch);
SAVE(fetch, resp->fetch);
/*
* We're done recursing, detach from quota and unlink from
@ -6332,9 +6307,9 @@ fetch_callback(isc_task_t *task, isc_event_t *event) {
/*
* Initialize a new qctx and use it to either resume from
* recursion or clean up after cancelation. Transfer
* ownership of devent to the new qctx in the process.
* ownership of resp to the new qctx in the process.
*/
qctx_init(client, &devent, 0, &qctx);
qctx_init(client, &resp, 0, &qctx);
if (fetch_canceled || fetch_answered) {
/*
@ -6545,7 +6520,7 @@ ns_query_recurse(ns_client_t *client, dns_rdatatype_t qtype, dns_name_t *qname,
result = dns_resolver_createfetch(
client->view->resolver, qname, qtype, qdomain, nameservers,
NULL, peeraddr, client->message->id, client->query.fetchoptions,
0, NULL, client->manager->task, fetch_callback, client,
0, NULL, client->manager->loop, fetch_callback, client,
rdataset, sigrdataset, &FETCH_RECTYPE_NORMAL(client));
if (result != ISC_R_SUCCESS) {
isc_nmhandle_detach(&HANDLE_RECTYPE_NORMAL(client));
@ -6626,13 +6601,13 @@ query_resume(query_ctx_t *qctx) {
RESTORE(qctx->sigrdataset, qctx->rpz_st->q.sigrdataset);
qctx->qtype = qctx->rpz_st->q.qtype;
if (qctx->event->node != NULL) {
dns_db_detachnode(qctx->event->db, &qctx->event->node);
if (qctx->fresp->node != NULL) {
dns_db_detachnode(qctx->fresp->db, &qctx->fresp->node);
}
SAVE(qctx->rpz_st->r.db, qctx->event->db);
qctx->rpz_st->r.r_type = qctx->event->qtype;
SAVE(qctx->rpz_st->r.r_rdataset, qctx->event->rdataset);
ns_client_putrdataset(qctx->client, &qctx->event->sigrdataset);
SAVE(qctx->rpz_st->r.db, qctx->fresp->db);
qctx->rpz_st->r.r_type = qctx->fresp->qtype;
SAVE(qctx->rpz_st->r.r_rdataset, qctx->fresp->rdataset);
ns_client_putrdataset(qctx->client, &qctx->fresp->sigrdataset);
} else if (REDIRECT(qctx->client)) {
/*
* Restore saved state.
@ -6662,23 +6637,23 @@ query_resume(query_ctx_t *qctx) {
/*
* Free resources used while recursing.
*/
ns_client_putrdataset(qctx->client, &qctx->event->rdataset);
ns_client_putrdataset(qctx->client, &qctx->event->sigrdataset);
if (qctx->event->node != NULL) {
dns_db_detachnode(qctx->event->db, &qctx->event->node);
ns_client_putrdataset(qctx->client, &qctx->fresp->rdataset);
ns_client_putrdataset(qctx->client, &qctx->fresp->sigrdataset);
if (qctx->fresp->node != NULL) {
dns_db_detachnode(qctx->fresp->db, &qctx->fresp->node);
}
if (qctx->event->db != NULL) {
dns_db_detach(&qctx->event->db);
if (qctx->fresp->db != NULL) {
dns_db_detach(&qctx->fresp->db);
}
} else {
CCTRACE(ISC_LOG_DEBUG(3), "resume from normal recursion");
qctx->authoritative = false;
qctx->qtype = qctx->event->qtype;
SAVE(qctx->db, qctx->event->db);
SAVE(qctx->node, qctx->event->node);
SAVE(qctx->rdataset, qctx->event->rdataset);
SAVE(qctx->sigrdataset, qctx->event->sigrdataset);
qctx->qtype = qctx->fresp->qtype;
SAVE(qctx->db, qctx->fresp->db);
SAVE(qctx->node, qctx->fresp->node);
SAVE(qctx->rdataset, qctx->fresp->rdataset);
SAVE(qctx->sigrdataset, qctx->fresp->sigrdataset);
}
INSIST(qctx->rdataset != NULL);
@ -6734,7 +6709,7 @@ query_resume(query_ctx_t *qctx) {
} else if (REDIRECT(qctx->client)) {
tname = qctx->client->query.redirect.fname;
} else {
tname = qctx->event->foundname;
tname = qctx->fresp->foundname;
}
dns_name_copy(tname, qctx->fname);
@ -6742,14 +6717,13 @@ query_resume(query_ctx_t *qctx) {
if (qctx->rpz_st != NULL &&
(qctx->rpz_st->state & DNS_RPZ_RECURSING) != 0)
{
qctx->rpz_st->r.r_result = qctx->event->result;
qctx->rpz_st->r.r_result = qctx->fresp->result;
result = qctx->rpz_st->q.result;
free_devent(qctx->client, ISC_EVENT_PTR(&qctx->event),
&qctx->event);
free_fresp(qctx->client, &qctx->fresp);
} else if (REDIRECT(qctx->client)) {
result = qctx->client->query.redirect.result;
} else {
result = qctx->event->result;
result = qctx->fresp->result;
}
qctx->resuming = true;

9
tests/dns/keytable_test.c
View file

@ -45,14 +45,12 @@
static int
setup_test(void **state) {
setup_loopmgr(state);
setup_taskmgr(state);
return (0);
}
static int
teardown_test(void **state) {
teardown_taskmgr(state);
teardown_loopmgr(state);
return (0);
@ -178,7 +176,7 @@ create_tables(void) {
ISC_R_SUCCESS);
assert_int_equal(dns_keytable_create(mctx, &keytable), ISC_R_SUCCESS);
assert_int_equal(dns_ntatable_create(view, taskmgr, loopmgr, &ntatable),
assert_int_equal(dns_ntatable_create(view, loopmgr, &ntatable),
ISC_R_SUCCESS);
/* Add a normal key */
@ -611,15 +609,12 @@ ISC_LOOP_TEST_IMPL(nta) {
result = dns_test_makeview("view", false, &myview);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_task_create(taskmgr, &myview->task, 0);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_view_initsecroots(myview, mctx);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_view_getsecroots(myview, &keytable);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_view_initntatable(myview, taskmgr, loopmgr);
result = dns_view_initntatable(myview, loopmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_view_getntatable(myview, &ntatable);
assert_int_equal(result, ISC_R_SUCCESS);

5
tests/dns/resolver_test.c
View file

@ -75,9 +75,8 @@ mkres(dns_resolver_t **resolverp) {
isc_result_t result;
isc_tlsctx_cache_create(mctx, &tlsctx_cache);
result = dns_resolver_create(view, loopmgr, taskmgr, 1, netmgr, 0,
tlsctx_cache, dispatchmgr, dispatch, NULL,
resolverp);
result = dns_resolver_create(view, loopmgr, 1, netmgr, 0, tlsctx_cache,
dispatchmgr, dispatch, NULL, resolverp);
assert_int_equal(result, ISC_R_SUCCESS);
}