/* 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) {
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,
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,
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;
}
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);
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;
};
/*%
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);
}
if (result != ISC_R_SUCCESS) {
dns_view_detach(&tat->view);
- isc_task_detach(&tat->task);
isc_mem_putanddetach(&tat->mctx, tat, sizeof(*tat));
}
}
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);
/*
}
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);
}
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;
*/
static void
expire_name(dns_adbname_t *adbname, dns_adbstatus_t astat) {
+ isc_result_t result;
+
REQUIRE(DNS_ADBNAME_VALID(adbname));
- REQUIRE(DNS_ADB_VALID(adbname->adb));
- isc_result_t result;
dns_adb_t *adb = adbname->adb;
+ REQUIRE(DNS_ADB_VALID(adb));
+
DP(DEF_LEVEL, "killing name %p", adbname);
/*
/* ... and LRU list */
ISC_LIST_UNLINK(adb->names_lru, adbname, link);
- dns_adbname_detach(&adbname);
+ dns_adbname_unref(adbname);
}
/*
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);
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,
};
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);
*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);
* 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.
}
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;
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);
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;
/*
* 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);
}
/*
/*
* 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;
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;
/*
* 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;
}
* 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.
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);
}
dns_rdataset_t rdataset;
dns_rdataset_t *nameservers = NULL;
unsigned int options;
- uint32_t tid = isc_tid();
REQUIRE(DNS_ADBNAME_VALID(adbname));
*/
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));
#include <isc/result.h>
#include <isc/safe.h>
#include <isc/sockaddr.h>
-#include <isc/task.h>
#include <isc/util.h>
#include <dns/adb.h>
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;
} 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);
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;
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) {
}
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;
dns_view_t *view = NULL;
REQUIRE(mctx != NULL);
- REQUIRE(taskmgr != NULL);
REQUIRE(nm != NULL);
REQUIRE(tlsctx_client_cache != NULL);
REQUIRE(clientp != NULL && *clientp == NULL);
.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);
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) {
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);
dns_dispatchmgr_detach(&client->dispatchmgr);
- isc_task_detach(&client->task);
-
client->magic = 0;
isc_mem_putanddetach(&client->mctx, client, sizeof(*client));
}
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
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);
}
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;
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 ||
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));
}
/*
if (db != NULL) {
dns_db_detach(&db);
}
- if (event != NULL) {
- isc_event_free(ISC_EVENT_PTR(&event));
- }
/*
* Limit the number of restarts.
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.
*
*
*\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.
*
#include <isc/event.h>
#include <isc/loop.h>
#include <isc/sockaddr.h>
+#include <isc/tls.h>
#include <dns/tsig.h>
#include <dns/types.h>
} 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);
/*%<
*
*\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.
#include <isc/refcount.h>
#include <isc/rwlock.h>
#include <isc/stdtime.h>
-#include <isc/task.h>
#include <isc/timer.h>
#include <dns/rdataset.h>
#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'.
*
#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>
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;
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)
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);
*
*\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.
*
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.
*
* 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.
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;
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.
*
isc_mutex_t lock;
bool frozen;
- isc_task_t *task;
+ isc_loop_t *loop;
bool cacheshared;
/* Configurable data. */
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.
*
*\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:
*
*/
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.
*
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. */
dns_resolver_cancelfetch(nta->fetch);
dns_resolver_destroyfetch(&nta->fetch);
}
+ isc_loop_detach(&nta->loop);
isc_mem_putanddetach(&nta->mctx, nta, sizeof(*nta));
}
}
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;
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);
return (ISC_R_SUCCESS);
-cleanup_task:
- isc_task_detach(&ntatable->task);
-
-cleanup_ntatable:
+cleanup:
isc_mem_putanddetach(&ntatable->mctx, ntatable, sizeof(*ntatable));
return (result);
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));
}
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) {
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() */
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);
#include <isc/siphash.h>
#include <isc/stats.h>
#include <isc/string.h>
-#include <isc/task.h>
#include <isc/tid.h>
#include <isc/time.h>
#include <isc/timer.h>
#include <dns/dnstap.h>
#include <dns/ds.h>
#include <dns/edns.h>
-#include <dns/events.h>
#include <dns/forward.h>
#include <dns/keytable.h>
#include <dns/log.h>
typedef struct fetchctx fetchctx_t;
typedef struct query {
- /* Locked by task event serialization. */
+ /* Locked by loop event serialization. */
unsigned int magic;
isc_refcount_t references;
fetchctx_t *fctx;
isc_mem_t *mctx;
isc_stdtime_t now;
- isc_task_t *restask;
+ isc_loop_t *loop;
unsigned int tid;
/* Atomic */
bool cloned;
bool spilled;
ISC_LINK(struct fetchctx) link;
- ISC_LIST(dns_fetchevent_t) events;
+ ISC_LIST(dns_fetchresponse_t) resps;
- /*% Locked by task event serialization. */
+ /*% Locked by loop event serialization. */
dns_fixedname_t dfname;
dns_name_t *domain;
dns_rdataset_t nameservers;
atomic_uint_fast32_t attributes;
- isc_loop_t *loop;
isc_timer_t *timer;
isc_time_t expires;
isc_time_t expires_try_stale;
dns_rdataclass_t rdclass;
isc_loopmgr_t *loopmgr;
isc_nm_t *nm;
- isc_taskmgr_t *taskmgr;
dns_view_t *view;
bool frozen;
unsigned int options;
isc_hashmap_t *counters;
isc_rwlock_t counters_lock;
- unsigned int ntasks;
- isc_task_t **tasks;
-
uint32_t lame_ttl;
ISC_LIST(alternate_t) alternates;
dns_rbt_t *algorithms;
const char *file, unsigned int line);
static void
-resume_qmin(isc_task_t *task, isc_event_t *event);
+resume_qmin(void *arg);
static isc_result_t
get_attached_fctx(dns_resolver_t *res, const dns_name_t *name,
valcreate(fetchctx_t *fctx, dns_message_t *message, dns_adbaddrinfo_t *addrinfo,
dns_name_t *name, dns_rdatatype_t type, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset, unsigned int valoptions,
- isc_task_t *task, isc_loop_t *loop) {
+ isc_loop_t *loop) {
dns_validator_t *validator = NULL;
dns_valarg_t *valarg = NULL;
isc_result_t result;
}
result = dns_validator_create(fctx->res->view, name, type, rdataset,
- sigrdataset, message, valoptions, task,
- loop, validated, valarg, &validator);
+ sigrdataset, message, valoptions, loop,
+ validated, valarg, &validator);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
inc_stats(fctx->res, dns_resstatscounter_val);
if ((valoptions & DNS_VALIDATOR_DEFER) == 0) {
static void
fctx_sendevents(fetchctx_t *fctx, isc_result_t result) {
- dns_fetchevent_t *event, *next_event;
- isc_task_t *task;
+ dns_fetchresponse_t *resp = NULL, *next = NULL;
unsigned int count = 0;
bool logit = false;
isc_time_t now;
TIME_NOW(&now);
fctx->duration = isc_time_microdiff(&now, &fctx->start);
- for (event = ISC_LIST_HEAD(fctx->events); event != NULL;
- event = next_event)
- {
- next_event = ISC_LIST_NEXT(event, ev_link);
- ISC_LIST_UNLINK(fctx->events, event, ev_link);
- if (event->ev_type == DNS_EVENT_TRYSTALE) {
+ for (resp = ISC_LIST_HEAD(fctx->resps); resp != NULL; resp = next) {
+ next = ISC_LIST_NEXT(resp, link);
+ ISC_LIST_UNLINK(fctx->resps, resp, link);
+ if (resp->type == TRYSTALE) {
/*
- * Not applicable to TRY STALE events, this function is
+ * Not applicable to TRYSTALE resps; this function is
* called when the fetch has either completed or timed
* out due to resolver-query-timeout being reached.
*/
- isc_task_detach((isc_task_t **)&event->ev_sender);
- isc_event_free((isc_event_t **)&event);
+ isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp));
continue;
}
- task = event->ev_sender;
- event->ev_sender = fctx;
- event->vresult = fctx->vresult;
+
+ resp->vresult = fctx->vresult;
if (!HAVE_ANSWER(fctx)) {
- event->result = result;
+ resp->result = result;
}
- INSIST(event->result != ISC_R_SUCCESS ||
- dns_rdataset_isassociated(event->rdataset) ||
+ INSIST(resp->result != ISC_R_SUCCESS ||
+ dns_rdataset_isassociated(resp->rdataset) ||
fctx->type == dns_rdatatype_any ||
fctx->type == dns_rdatatype_rrsig ||
fctx->type == dns_rdatatype_sig);
/*
- * Negative results must be indicated in event->result.
+ * Negative results must be indicated in resp->result.
*/
- if (dns_rdataset_isassociated(event->rdataset) &&
- NEGATIVE(event->rdataset))
+ if (dns_rdataset_isassociated(resp->rdataset) &&
+ NEGATIVE(resp->rdataset))
{
- INSIST(event->result == DNS_R_NCACHENXDOMAIN ||
- event->result == DNS_R_NCACHENXRRSET);
+ INSIST(resp->result == DNS_R_NCACHENXDOMAIN ||
+ resp->result == DNS_R_NCACHENXRRSET);
}
- FCTXTRACE("event");
- isc_task_sendanddetach(&task, ISC_EVENT_PTR(&event));
+ FCTXTRACE("post response event");
+ isc_async_run(resp->loop, resp->cb, resp);
count++;
}
UNLOCK(&fctx->lock);
static isc_result_t
resquery_timeout(resquery_t *query) {
fetchctx_t *fctx = query->fctx;
- dns_fetchevent_t *event = NULL, *next = NULL;
+ dns_fetchresponse_t *resp = NULL, *next = NULL;
uint64_t timeleft;
isc_time_t now;
* Send the TRYSTALE events.
*/
LOCK(&fctx->lock);
- for (event = ISC_LIST_HEAD(fctx->events); event != NULL; event = next) {
- isc_task_t *sender = NULL;
-
- next = ISC_LIST_NEXT(event, ev_link);
- if (event->ev_type != DNS_EVENT_TRYSTALE) {
+ for (resp = ISC_LIST_HEAD(fctx->resps); resp != NULL; resp = next) {
+ next = ISC_LIST_NEXT(resp, link);
+ if (resp->type != TRYSTALE) {
continue;
}
- ISC_LIST_UNLINK(fctx->events, event, ev_link);
-
- sender = event->ev_sender;
- event->vresult = ISC_R_TIMEDOUT;
- event->result = ISC_R_TIMEDOUT;
- isc_task_sendanddetach(&sender, ISC_EVENT_PTR(&event));
+ ISC_LIST_UNLINK(fctx->resps, resp, link);
+ resp->vresult = ISC_R_TIMEDOUT;
+ resp->result = ISC_R_TIMEDOUT;
+ isc_async_run(resp->loop, resp->cb, resp);
}
UNLOCK(&fctx->lock);
result = dns_resolver_createfetch(
fctx->res, fctx->qminname, fctx->qmintype, fctx->domain,
&fctx->nameservers, NULL, NULL, 0, options, 0, fctx->qc,
- fctx->restask, resume_qmin, fctx, &fctx->qminrrset,
- NULL, &fctx->qminfetch);
+ fctx->loop, resume_qmin, fctx, &fctx->qminrrset, NULL,
+ &fctx->qminfetch);
if (result != ISC_R_SUCCESS) {
fetchctx_unref(fctx);
goto done;
}
static void
-resume_qmin(isc_task_t *task, isc_event_t *event) {
- dns_fetchevent_t *fevent = NULL;
+resume_qmin(void *arg) {
+ dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg;
+ fetchctx_t *fctx = resp->arg;
dns_resolver_t *res = NULL;
- fetchctx_t *fctx = NULL;
isc_result_t result;
unsigned int findoptions = 0;
dns_name_t *fname = NULL, *dcname = NULL;
dns_fixedname_t ffixed, dcfixed;
- UNUSED(task);
-
- REQUIRE(event->ev_type == DNS_EVENT_FETCHDONE);
- fevent = (dns_fetchevent_t *)event;
- fctx = event->ev_arg;
REQUIRE(VALID_FCTX(fctx));
+ REQUIRE(resp->type == FETCHDONE);
+
res = fctx->res;
REQUIRE(fctx->tid == isc_tid());
fname = dns_fixedname_initname(&ffixed);
dcname = dns_fixedname_initname(&dcfixed);
- if (fevent->node != NULL) {
- dns_db_detachnode(fevent->db, &fevent->node);
+ if (resp->node != NULL) {
+ dns_db_detachnode(resp->db, &resp->node);
}
- if (fevent->db != NULL) {
- dns_db_detach(&fevent->db);
+ if (resp->db != NULL) {
+ dns_db_detach(&resp->db);
}
- if (dns_rdataset_isassociated(fevent->rdataset)) {
- dns_rdataset_disassociate(fevent->rdataset);
+ if (dns_rdataset_isassociated(resp->rdataset)) {
+ dns_rdataset_disassociate(resp->rdataset);
}
- result = fevent->result;
- isc_event_free(&event);
+ result = resp->result;
+ isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp));
LOCK(&fctx->lock);
if (SHUTTINGDOWN(fctx)) {
uint_fast32_t nfctx;
REQUIRE(VALID_FCTX(fctx));
- REQUIRE(ISC_LIST_EMPTY(fctx->events));
+ REQUIRE(ISC_LIST_EMPTY(fctx->resps));
REQUIRE(ISC_LIST_EMPTY(fctx->queries));
REQUIRE(ISC_LIST_EMPTY(fctx->finds));
REQUIRE(ISC_LIST_EMPTY(fctx->altfinds));
}
static void
-fctx_start(fetchctx_t *fctx) {
+fctx_start(void *arg) {
+ fetchctx_t *fctx = (fetchctx_t *)arg;
+
REQUIRE(VALID_FCTX(fctx));
FCTXTRACE("start");
UNLOCK(&fctx->lock);
goto detach;
}
+
+ /*
+ * Normal fctx startup.
+ */
+ fctx->state = fetchstate_active;
UNLOCK(&fctx->lock);
/*
*/
static void
-fctx_add_event(fetchctx_t *fctx, isc_task_t *task, const isc_sockaddr_t *client,
- dns_messageid_t id, isc_taskaction_t action, void *arg,
+fctx_add_event(fetchctx_t *fctx, isc_loop_t *loop, const isc_sockaddr_t *client,
+ dns_messageid_t id, isc_job_cb cb, void *arg,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
- dns_fetch_t *fetch, isc_eventtype_t event_type) {
- dns_fetchevent_t *event = NULL;
+ dns_fetch_t *fetch, int type) {
+ dns_fetchresponse_t *resp = NULL;
FCTXTRACE("addevent");
- /*
- * We store the task we're going to send this event to in the
- * sender field. We'll make the fetch the sender when we
- * actually send the event.
- */
- isc_task_ref(task);
- event = (dns_fetchevent_t *)isc_event_allocate(
- fctx->mctx, task, event_type, action, arg, sizeof(*event));
- event->result = DNS_R_SERVFAIL;
- event->qtype = fctx->type;
- event->db = NULL;
- event->node = NULL;
- event->rdataset = rdataset;
- event->sigrdataset = sigrdataset;
- event->fetch = fetch;
- event->client = client;
- event->id = id;
- event->foundname = dns_fixedname_initname(&event->fname);
+ resp = isc_mem_get(fctx->res->mctx, sizeof(*resp));
+ *resp = (dns_fetchresponse_t){
+ .result = DNS_R_SERVFAIL,
+ .qtype = fctx->type,
+ .rdataset = rdataset,
+ .sigrdataset = sigrdataset,
+ .fetch = fetch,
+ .client = client,
+ .id = id,
+ .type = type,
+ .loop = loop,
+ .cb = cb,
+ .arg = arg,
+ .link = ISC_LINK_INITIALIZER,
+ };
+ isc_mem_attach(fctx->res->mctx, &resp->mctx);
+
+ resp->foundname = dns_fixedname_initname(&resp->fname);
/*
- * Store the sigrdataset in the first event in case it is needed
+ * Store the sigrdataset in the first resp in case it is needed
* by any of the events.
*/
- if (event->sigrdataset != NULL) {
- ISC_LIST_PREPEND(fctx->events, event, ev_link);
+ if (resp->sigrdataset != NULL) {
+ ISC_LIST_PREPEND(fctx->resps, resp, link);
} else {
- ISC_LIST_APPEND(fctx->events, event, ev_link);
+ ISC_LIST_APPEND(fctx->resps, resp, link);
}
}
static void
-fctx_join(fetchctx_t *fctx, isc_task_t *task, const isc_sockaddr_t *client,
- dns_messageid_t id, isc_taskaction_t action, void *arg,
+fctx_join(fetchctx_t *fctx, isc_loop_t *loop, const isc_sockaddr_t *client,
+ dns_messageid_t id, isc_job_cb cb, void *arg,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
dns_fetch_t *fetch) {
FCTXTRACE("join");
REQUIRE(!SHUTTINGDOWN(fctx));
- fctx_add_event(fctx, task, client, id, action, arg, rdataset,
- sigrdataset, fetch, DNS_EVENT_FETCHDONE);
+ fctx_add_event(fctx, loop, client, id, cb, arg, rdataset, sigrdataset,
+ fetch, FETCHDONE);
fetch->magic = DNS_FETCH_MAGIC;
fetchctx_attach(fctx, &fetch->private);
.qmintype = type,
.options = options,
.tid = tid,
- .restask = res->tasks[tid],
.state = fetchstate_active,
.depth = depth,
.qmin_labels = 1,
dns_db_attach(res->view->cachedb, &fctx->cache);
dns_adb_attach(res->view->adb, &fctx->adb);
- ISC_LIST_INIT(fctx->events);
+ ISC_LIST_INIT(fctx->resps);
ISC_LINK_INIT(fctx, link);
fctx->magic = FCTX_MAGIC;
static void
clone_results(fetchctx_t *fctx) {
- dns_fetchevent_t *event = NULL, *hevent = NULL;
+ dns_fetchresponse_t *resp = NULL, *hresp = NULL;
FCTXTRACE("clone_results");
/*
- * Set up any other events to have the same data as the first
- * event.
+ * Set up any other resps to have the same data as the first.
*
* Caller must be holding the appropriate lock.
*/
fctx->cloned = true;
- for (event = ISC_LIST_HEAD(fctx->events); event != NULL;
- event = ISC_LIST_NEXT(event, ev_link))
+ for (resp = ISC_LIST_HEAD(fctx->resps); resp != NULL;
+ resp = ISC_LIST_NEXT(resp, link))
{
- /* This is the the head event; keep a pointer and move
- * on */
- if (hevent == NULL) {
- hevent = ISC_LIST_HEAD(fctx->events);
+ /* This is the head resp; keep a pointer and move on */
+ if (hresp == NULL) {
+ hresp = ISC_LIST_HEAD(fctx->resps);
continue;
}
- if (event->ev_type == DNS_EVENT_TRYSTALE) {
+ if (resp->type == TRYSTALE) {
/*
* We don't need to clone resulting data to this
* type of event, as its associated callback is
* Also, if we reached this point, then the
* whole fetch context is done, it will cancel
* timers, process associated callbacks of type
- * DNS_EVENT_FETCHDONE, and silently remove/free
- * events of type DNS_EVENT_TRYSTALE.
+ * FETCHDONE, and silently remove/free events of
+ * type TRYSTALE.
*/
continue;
}
- event->result = hevent->result;
- dns_name_copy(hevent->foundname, event->foundname);
- dns_db_attach(hevent->db, &event->db);
- dns_db_attachnode(hevent->db, hevent->node, &event->node);
+ resp->result = hresp->result;
+ dns_name_copy(hresp->foundname, resp->foundname);
+ dns_db_attach(hresp->db, &resp->db);
+ dns_db_attachnode(hresp->db, hresp->node, &resp->node);
- INSIST(hevent->rdataset != NULL);
- INSIST(event->rdataset != NULL);
- if (dns_rdataset_isassociated(hevent->rdataset)) {
- dns_rdataset_clone(hevent->rdataset, event->rdataset);
+ INSIST(hresp->rdataset != NULL);
+ INSIST(resp->rdataset != NULL);
+ if (dns_rdataset_isassociated(hresp->rdataset)) {
+ dns_rdataset_clone(hresp->rdataset, resp->rdataset);
}
- INSIST(!(hevent->sigrdataset == NULL &&
- event->sigrdataset != NULL));
- if (hevent->sigrdataset != NULL &&
- dns_rdataset_isassociated(hevent->sigrdataset) &&
- event->sigrdataset != NULL)
+ INSIST(!(hresp->sigrdataset == NULL &&
+ resp->sigrdataset != NULL));
+ if (hresp->sigrdataset != NULL &&
+ dns_rdataset_isassociated(hresp->sigrdataset) &&
+ resp->sigrdataset != NULL)
{
- dns_rdataset_clone(hevent->sigrdataset,
- event->sigrdataset);
+ dns_rdataset_clone(hresp->sigrdataset,
+ resp->sigrdataset);
}
}
}
dns_adbaddrinfo_t *addrinfo = NULL;
dns_dbnode_t *node = NULL;
dns_dbnode_t *nsnode = NULL;
- dns_fetchevent_t *hevent = NULL;
+ dns_fetchresponse_t *hresp = NULL;
dns_name_t *name = NULL;
dns_rdataset_t *ardataset = NULL;
dns_rdataset_t *asigrdataset = NULL;
* started by a query with cd set)
*/
- hevent = ISC_LIST_HEAD(fctx->events);
- if (hevent != NULL) {
+ hresp = ISC_LIST_HEAD(fctx->resps);
+ if (hresp != NULL) {
if (!negative && !chaining &&
(fctx->type == dns_rdatatype_any ||
fctx->type == dns_rdatatype_rrsig ||
* will iterate the node.
*/
} else {
- ardataset = hevent->rdataset;
- asigrdataset = hevent->sigrdataset;
+ ardataset = hresp->rdataset;
+ asigrdataset = hresp->sigrdataset;
}
}
add_bad(fctx, message, addrinfo, result, badns_validation);
UNLOCK(&fctx->lock);
+
INSIST(fctx->validator == NULL);
fctx->validator = ISC_LIST_HEAD(fctx->validators);
* cache the data, destroy now.
*/
dns_db_detachnode(fctx->cache, &node);
+ if (SHUTTINGDOWN(fctx)) {
+ maybe_cancel_validators(fctx);
+ }
UNLOCK(&fctx->lock);
goto cleanup_fetchctx;
}
FCTX_ATTR_SET(fctx, FCTX_ATTR_HAVEANSWER);
- if (hevent != NULL) {
+ if (hresp != NULL) {
/*
* Negative results must be indicated in vstat->result.
*/
- INSIST(hevent->rdataset != NULL);
- if (dns_rdataset_isassociated(hevent->rdataset) &&
- NEGATIVE(hevent->rdataset))
+ INSIST(hresp->rdataset != NULL);
+ if (dns_rdataset_isassociated(hresp->rdataset) &&
+ NEGATIVE(hresp->rdataset))
{
INSIST(eresult == DNS_R_NCACHENXDOMAIN ||
eresult == DNS_R_NCACHENXRRSET);
}
- hevent->result = eresult;
- dns_name_copy(vstat->name, hevent->foundname);
- dns_db_attach(fctx->cache, &hevent->db);
- dns_db_transfernode(fctx->cache, &node, &hevent->node);
+ hresp->result = eresult;
+ dns_name_copy(vstat->name, hresp->foundname);
+ dns_db_attach(fctx->cache, &hresp->db);
+ dns_db_transfernode(fctx->cache, &node, &hresp->node);
clone_results(fctx);
}
bool secure_domain = false;
bool have_answer = false;
isc_result_t result, eresult = ISC_R_SUCCESS;
- dns_fetchevent_t *event = NULL;
+ dns_fetchresponse_t *resp = NULL;
unsigned int options;
bool fail;
unsigned int valoptions = 0;
if (name->attributes.answer && !need_validation) {
have_answer = true;
- event = ISC_LIST_HEAD(fctx->events);
+ resp = ISC_LIST_HEAD(fctx->resps);
- if (event != NULL) {
- adbp = &event->db;
- dns_name_copy(name, event->foundname);
- anodep = &event->node;
+ if (resp != NULL) {
+ adbp = &resp->db;
+ dns_name_copy(name, resp->foundname);
+ anodep = &resp->node;
/*
* If this is an ANY, SIG or RRSIG query, we're
fctx->type != dns_rdatatype_sig) ||
name->attributes.chaining)
{
- ardataset = event->rdataset;
- asigrdataset = event->sigrdataset;
+ ardataset = resp->rdataset;
+ asigrdataset = resp->sigrdataset;
}
}
}
fctx, message, addrinfo, name,
rdataset->type, rdataset,
sigrdataset, valoptions,
- fctx->restask, fctx->loop);
+ fctx->loop);
}
} else if (CHAINING(rdataset)) {
if (rdataset->type == dns_rdatatype_cname) {
result = valcreate(fctx, message, addrinfo, name, vtype,
valrdataset, valsigrdataset, valoptions,
- fctx->restask, fctx->loop);
+ fctx->loop);
}
if (result == ISC_R_SUCCESS && have_answer) {
FCTX_ATTR_SET(fctx, FCTX_ATTR_HAVEANSWER);
- if (event != NULL) {
+ if (resp != NULL) {
/*
* Negative results must be indicated in
- * event->result.
+ * resp->result.
*/
- if (dns_rdataset_isassociated(event->rdataset) &&
- NEGATIVE(event->rdataset))
+ if (dns_rdataset_isassociated(resp->rdataset) &&
+ NEGATIVE(resp->rdataset))
{
INSIST(eresult == DNS_R_NCACHENXDOMAIN ||
eresult == DNS_R_NCACHENXRRSET);
}
- event->result = eresult;
+ resp->result = eresult;
if (adbp != NULL && *adbp != NULL) {
if (anodep != NULL && *anodep != NULL) {
dns_db_detachnode(*adbp, anodep);
dns_dbnode_t *node = NULL, **anodep = NULL;
dns_rdataset_t *ardataset = NULL;
bool need_validation = false, secure_domain = false;
- dns_fetchevent_t *event = NULL;
+ dns_fetchresponse_t *resp = NULL;
uint32_t ttl;
unsigned int valoptions = 0;
bool checknta = true;
* Do negative response validation.
*/
result = valcreate(fctx, message, addrinfo, name, fctx->type,
- NULL, NULL, valoptions, fctx->restask,
- fctx->loop);
+ NULL, NULL, valoptions, fctx->loop);
/*
* If validation is necessary, return now. Otherwise
* continue to process the message, letting the
LOCK(&fctx->lock);
if (!HAVE_ANSWER(fctx)) {
- event = ISC_LIST_HEAD(fctx->events);
- if (event != NULL) {
- adbp = &event->db;
- dns_name_copy(name, event->foundname);
- anodep = &event->node;
- ardataset = event->rdataset;
+ resp = ISC_LIST_HEAD(fctx->resps);
+ if (resp != NULL) {
+ adbp = &resp->db;
+ dns_name_copy(name, resp->foundname);
+ anodep = &resp->node;
+ ardataset = resp->rdataset;
}
}
if (!HAVE_ANSWER(fctx)) {
FCTX_ATTR_SET(fctx, FCTX_ATTR_HAVEANSWER);
- if (event != NULL) {
- event->result = eresult;
+ if (resp != NULL) {
+ resp->result = eresult;
if (adbp != NULL && *adbp != NULL) {
if (anodep != NULL && *anodep != NULL) {
dns_db_detachnode(*adbp, anodep);
}
static void
-resume_dslookup(isc_task_t *task, isc_event_t *event) {
+resume_dslookup(void *arg) {
+ dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg;
+ fetchctx_t *fctx = resp->arg;
+ isc_loop_t *loop = resp->loop;
isc_result_t result;
- dns_fetchevent_t *fevent = (dns_fetchevent_t *)event;
- fetchctx_t *fctx = event->ev_arg;
dns_resolver_t *res = NULL;
- dns_rdataset_t *nsrdataset = NULL;
+ dns_rdataset_t *frdataset = NULL, *nsrdataset = NULL;
dns_rdataset_t nameservers;
dns_fixedname_t fixed;
dns_name_t *domain = NULL;
unsigned int n;
dns_fetch_t *fetch = NULL;
- REQUIRE(event->ev_type == DNS_EVENT_FETCHDONE);
-
+ REQUIRE(resp->type == FETCHDONE);
REQUIRE(VALID_FCTX(fctx));
+
res = fctx->res;
REQUIRE(fctx->tid == isc_tid());
- UNUSED(task);
FCTXTRACE("resume_dslookup");
- if (fevent->node != NULL) {
- dns_db_detachnode(fevent->db, &fevent->node);
+ if (resp->node != NULL) {
+ dns_db_detachnode(resp->db, &resp->node);
}
- if (fevent->db != NULL) {
- dns_db_detach(&fevent->db);
+ if (resp->db != NULL) {
+ dns_db_detach(&resp->db);
}
- result = fevent->result;
+ /* Preserve data from resp before freeing it. */
+ frdataset = resp->rdataset;
+ result = resp->result;
+ isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp));
LOCK(&fctx->lock);
if (SHUTTINGDOWN(fctx)) {
if (dns_rdataset_isassociated(&fctx->nameservers)) {
dns_rdataset_disassociate(&fctx->nameservers);
}
- dns_rdataset_clone(fevent->rdataset, &fctx->nameservers);
+ dns_rdataset_clone(frdataset, &fctx->nameservers);
fctx->ns_ttl = fctx->nameservers.ttl;
fctx->ns_ttl_ok = true;
fetchctx_ref(fctx);
result = dns_resolver_createfetch(
res, fctx->nsname, dns_rdatatype_ns, domain, nsrdataset,
- NULL, NULL, 0, fctx->options, 0, NULL, task,
+ NULL, NULL, 0, fctx->options, 0, NULL, loop,
resume_dslookup, fctx, &fctx->nsrrset, NULL,
&fctx->nsfetch);
if (result != ISC_R_SUCCESS) {
cleanup:
dns_resolver_destroyfetch(&fetch);
- if (dns_rdataset_isassociated(fevent->rdataset)) {
- dns_rdataset_disassociate(fevent->rdataset);
+ if (dns_rdataset_isassociated(frdataset)) {
+ dns_rdataset_disassociate(frdataset);
}
- isc_event_free(&event);
-
if (result != ISC_R_SUCCESS) {
/* An error occurred, tear down whole fctx */
fctx_done_unref(fctx, result);
/*
* rctx_respinit():
* Initialize the response context structure 'rctx' to all zeroes, then
- * set the task, event, query and fctx information from
+ * set the loop, event, query and fctx information from
* resquery_response().
*/
static void
fetchctx_ref(fctx);
result = dns_resolver_createfetch(
fctx->res, fctx->nsname, dns_rdatatype_ns, NULL, NULL, NULL,
- NULL, 0, fctx->options, 0, NULL, fctx->restask, resume_dslookup,
+ NULL, 0, fctx->options, 0, NULL, fctx->loop, resume_dslookup,
fctx, &fctx->nsrrset, NULL, &fctx->nsfetch);
if (result != ISC_R_SUCCESS) {
if (result == DNS_R_DUPLICATE) {
* If nobody's waiting for results, don't resend or try next server.
*/
LOCK(&fctx->lock);
- if (ISC_LIST_EMPTY(fctx->events)) {
+ if (ISC_LIST_EMPTY(fctx->resps)) {
rctx->next_server = false;
rctx->resend = false;
}
isc_mutex_destroy(&res->primelock);
isc_mutex_destroy(&res->lock);
- for (size_t i = 0; i < res->ntasks; i++) {
- isc_task_detach(&res->tasks[i]);
- }
- isc_mem_put(res->mctx, res->tasks, res->ntasks * sizeof(res->tasks[0]));
-
INSIST(isc_hashmap_count(res->fctxs) == 0);
isc_hashmap_destroy(&res->fctxs);
isc_rwlock_destroy(&res->fctxs_lock);
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) {
isc_result_t result = ISC_R_SUCCESS;
- char name[sizeof("res4294967295")];
dns_resolver_t *res = NULL;
/*
.loopmgr = loopmgr,
.rdclass = view->rdclass,
.nm = nm,
- .taskmgr = taskmgr,
.dispatchmgr = dispatchmgr,
.options = options,
.tlsctx_cache = tlsctx_cache,
.query_timeout = DEFAULT_QUERY_TIMEOUT,
.maxdepth = DEFAULT_RECURSION_DEPTH,
.maxqueries = DEFAULT_MAX_QUERIES,
- .ntasks = isc_loopmgr_nloops(loopmgr),
.alternates = ISC_LIST_INITIALIZER,
};
result = dns_badcache_init(res->mctx, DNS_RESOLVER_BADCACHESIZE,
&res->badcache);
if (result != ISC_R_SUCCESS) {
- goto cleanup_res;
- }
-
- res->tasks = isc_mem_getx(
- res->mctx, res->ntasks * sizeof(res->tasks[0]), ISC_MEM_ZERO);
- for (uint32_t i = 0; i < res->ntasks; i++) {
- /*
- * Since we have a pool of tasks we bind them to task
- * queues to spread the load evenly
- */
- result = isc_task_create(taskmgr, &res->tasks[i], i);
- if (result != ISC_R_SUCCESS) {
- goto cleanup_tasks;
- }
-
- snprintf(name, sizeof(name), "res%" PRIu32, i);
- isc_task_setname(res->tasks[i], name, res);
+ goto cleanup;
}
/* This needs to be case sensitive to not lowercase options and type */
return (ISC_R_SUCCESS);
-cleanup_tasks:
- for (size_t i = 0; i < res->ntasks; i++) {
- if (res->tasks[i] != NULL) {
- isc_task_detach(&res->tasks[i]);
- }
- }
- isc_mem_put(res->mctx, res->tasks, res->ntasks * sizeof(res->tasks[0]));
-
- dns_badcache_destroy(&res->badcache);
-
-cleanup_res:
+cleanup:
dns_view_weakdetach(&res->view);
isc_mem_putanddetach(&res->mctx, res, sizeof(*res));
return (result);
}
static void
-prime_done(isc_task_t *task, isc_event_t *event) {
- dns_resolver_t *res;
- dns_fetchevent_t *fevent;
- dns_fetch_t *fetch;
+prime_done(void *arg) {
+ dns_fetchresponse_t *resp = (dns_fetchresponse_t *)arg;
+ dns_resolver_t *res = resp->arg;
+ dns_fetch_t *fetch = NULL;
dns_db_t *db = NULL;
- REQUIRE(event->ev_type == DNS_EVENT_FETCHDONE);
- fevent = (dns_fetchevent_t *)event;
- res = event->ev_arg;
+ REQUIRE(resp->type == FETCHDONE);
REQUIRE(VALID_RESOLVER(res));
isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
DNS_LOGMODULE_RESOLVER, ISC_LOG_INFO,
"resolver priming query complete: %s",
- isc_result_totext(fevent->result));
-
- UNUSED(task);
+ isc_result_totext(resp->result));
LOCK(&res->primelock);
fetch = res->primefetch;
atomic_compare_exchange_enforced(&res->priming, &(bool){ true }, false);
- if (fevent->result == ISC_R_SUCCESS && res->view->cache != NULL &&
+ if (resp->result == ISC_R_SUCCESS && res->view->cache != NULL &&
res->view->hints != NULL)
{
dns_cache_attachdb(res->view->cache, &db);
dns_db_detach(&db);
}
- if (fevent->node != NULL) {
- dns_db_detachnode(fevent->db, &fevent->node);
+ if (resp->node != NULL) {
+ dns_db_detachnode(resp->db, &resp->node);
}
- if (fevent->db != NULL) {
- dns_db_detach(&fevent->db);
+ if (resp->db != NULL) {
+ dns_db_detach(&resp->db);
}
- if (dns_rdataset_isassociated(fevent->rdataset)) {
- dns_rdataset_disassociate(fevent->rdataset);
+ if (dns_rdataset_isassociated(resp->rdataset)) {
+ dns_rdataset_disassociate(resp->rdataset);
}
- INSIST(fevent->sigrdataset == NULL);
-
- isc_mem_put(res->mctx, fevent->rdataset, sizeof(*fevent->rdataset));
+ INSIST(resp->sigrdataset == NULL);
- isc_event_free(&event);
+ isc_mem_put(res->mctx, resp->rdataset, sizeof(*resp->rdataset));
+ isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp));
dns_resolver_destroyfetch(&fetch);
}
LOCK(&res->primelock);
result = dns_resolver_createfetch(
res, dns_rootname, dns_rdatatype_ns, NULL, NULL, NULL,
- NULL, 0, DNS_FETCHOPT_NOFORWARD, 0, NULL, res->tasks[0],
- prime_done, res, rdataset, NULL, &res->primefetch);
+ NULL, 0, DNS_FETCHOPT_NOFORWARD, 0, NULL,
+ isc_loop_main(res->loopmgr), prime_done, res, rdataset,
+ NULL, &res->primefetch);
UNLOCK(&res->primelock);
if (result != ISC_R_SUCCESS) {
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) {
dns_fetch_t *fetch = NULL;
fetchctx_t *fctx = NULL;
isc_result_t result = ISC_R_SUCCESS;
INSIST(!SHUTTINGDOWN(fctx));
- /*
- * Is this a duplicate?
- */
- if (client != NULL) {
- dns_fetchevent_t *fevent;
- for (fevent = ISC_LIST_HEAD(fctx->events);
- fevent != NULL;
- fevent = ISC_LIST_NEXT(fevent, ev_link))
+ /* Is this a duplicate? */
+ if (fctx != NULL && client != NULL) {
+ dns_fetchresponse_t *resp = NULL;
+ for (resp = ISC_LIST_HEAD(fctx->resps); resp != NULL;
+ resp = ISC_LIST_NEXT(resp, link))
{
- if (fevent->client != NULL &&
- fevent->id == id &&
- isc_sockaddr_equal(fevent->client, client))
+ if (resp->client != NULL && resp->id == id &&
+ isc_sockaddr_equal(resp->client, client))
{
result = DNS_R_DUPLICATE;
goto unlock;
fctx->depth = depth;
}
- fctx_join(fctx, task, client, id, action, arg, rdataset, sigrdataset,
+ fctx_join(fctx, loop, client, id, cb, arg, rdataset, sigrdataset,
fetch);
if ((options & DNS_FETCHOPT_TRYSTALE_ONTIMEOUT) != 0) {
- fctx_add_event(fctx, task, client, id, action, arg, NULL, NULL,
- fetch, DNS_EVENT_TRYSTALE);
+ fctx_add_event(fctx, loop, client, id, cb, arg, NULL, NULL,
+ fetch, TRYSTALE);
}
if (new_fctx) {
void
dns_resolver_cancelfetch(dns_fetch_t *fetch) {
fetchctx_t *fctx = NULL;
- dns_fetchevent_t *event_trystale = NULL;
- dns_fetchevent_t *event_fetchdone = NULL;
+ dns_fetchresponse_t *trystale = NULL;
+ dns_fetchresponse_t *fetchdone = NULL;
REQUIRE(DNS_FETCH_VALID(fetch));
fctx = fetch->private;
LOCK(&fctx->lock);
/*
- * Find all the events associated with the provided 'fetch' (as opposed
- * to those for other fetches that have joined the same fctx). The
- * event(s) found are only sent and removed from the fctx->events list
- * after this loop is finished (i.e. the fctx->events list is not
+ * Find completion events associated with this fetch (as opposed
+ * to those for other fetches that have joined the same fctx).
+ * The event(s) found are only sent and removed from the fctx->resps
+ * list after this loop is finished (i.e. the fctx->resps list is not
* modified during iteration).
*/
- for (dns_fetchevent_t *event = ISC_LIST_HEAD(fctx->events);
- event != NULL; event = ISC_LIST_NEXT(event, ev_link))
- {
- /*
- * Only process events associated with the provided 'fetch'.
- */
- if (event->fetch != fetch) {
- continue;
- }
+ if (fctx->state != fetchstate_done) {
+ dns_fetchresponse_t *next = NULL;
+ for (dns_fetchresponse_t *resp = ISC_LIST_HEAD(fctx->resps);
+ resp != NULL; resp = next)
+ {
+ next = ISC_LIST_NEXT(resp, link);
- /*
- * Track various events associated with the provided 'fetch' in
- * separate variables as they will need to be sent in a
- * specific order.
- */
- switch (event->ev_type) {
- case DNS_EVENT_TRYSTALE:
- INSIST(event_trystale == NULL);
- event_trystale = event;
- break;
- case DNS_EVENT_FETCHDONE:
- INSIST(event_fetchdone == NULL);
- event_fetchdone = event;
- break;
- default:
- UNREACHABLE();
- }
+ /*
+ * Only process events associated with the provided
+ * 'fetch'.
+ */
+ if (resp->fetch != fetch) {
+ continue;
+ }
- /*
- * Break out of the loop once all possible types of events
- * associated with the provided 'fetch' are found.
- */
- if (event_trystale != NULL && event_fetchdone != NULL) {
- break;
+ /*
+ * Track various events associated with the
+ * provided 'fetch' in separate variables as they
+ * will need to be sent in a specific order.
+ */
+ switch (resp->type) {
+ case TRYSTALE:
+ INSIST(trystale == NULL);
+ trystale = resp;
+ break;
+ case FETCHDONE:
+ INSIST(fetchdone == NULL);
+ fetchdone = resp;
+ break;
+ default:
+ UNREACHABLE();
+ }
+
+ /*
+ * Break out of the loop once all possible types of
+ * events associated with the provided 'fetch' are
+ * found.
+ */
+ if (trystale != NULL && fetchdone != NULL) {
+ break;
+ }
}
}
* because the latter clears the "recursing" query attribute, which is
* required by both events (handled by the same callback function).
*/
- if (event_trystale != NULL) {
- isc_task_t *etask = event_trystale->ev_sender;
- ISC_LIST_UNLINK(fctx->events, event_trystale, ev_link);
- event_trystale->ev_sender = fctx;
- event_trystale->result = ISC_R_CANCELED;
- isc_task_sendanddetach(&etask, ISC_EVENT_PTR(&event_trystale));
+ if (trystale != NULL) {
+ trystale->result = ISC_R_CANCELED;
+ ISC_LIST_UNLINK(fctx->resps, trystale, link);
+ isc_async_run(trystale->loop, trystale->cb, trystale);
}
- if (event_fetchdone != NULL) {
- isc_task_t *etask = event_fetchdone->ev_sender;
- ISC_LIST_UNLINK(fctx->events, event_fetchdone, ev_link);
- event_fetchdone->ev_sender = fctx;
- event_fetchdone->result = ISC_R_CANCELED;
- isc_task_sendanddetach(&etask, ISC_EVENT_PTR(&event_fetchdone));
+ if (fetchdone != NULL) {
+ fetchdone->result = ISC_R_CANCELED;
+ ISC_LIST_UNLINK(fctx->resps, fetchdone, link);
+ isc_async_run(fetchdone->loop, fetchdone->cb, fetchdone);
}
/*
* Sanity check: the caller should have gotten its event before
* trying to destroy the fetch.
*/
- for (dns_fetchevent_t *event = ISC_LIST_HEAD(fctx->events);
- event != NULL; event = ISC_LIST_NEXT(event, ev_link))
- {
- RUNTIME_CHECK(event->fetch != fetch);
+ if (fctx->state != fetchstate_done) {
+ dns_fetchresponse_t *resp = NULL, *next = NULL;
+ for (resp = ISC_LIST_HEAD(fctx->resps); resp != NULL;
+ resp = next)
+ {
+ next = ISC_LIST_NEXT(resp, link);
+ RUNTIME_CHECK(resp->fetch != fetch);
+ }
}
UNLOCK(&fctx->lock);
isc_stats_attach(stats, &res->stats);
/* initialize the bucket "counter"; it's a static value */
- set_stats(res, dns_resstatscounter_buckets, res->ntasks);
+ set_stats(res, dns_resstatscounter_buckets,
+ isc_loopmgr_nloops(res->loopmgr));
}
void
#include <isc/mem.h>
#include <isc/result.h>
#include <isc/string.h>
-#include <isc/task.h>
#include <isc/util.h>
#include <dns/client.h>
}
/*
- * 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.
* 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);
* 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
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);
} 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))
{
/*
}
done:
- isc_event_free(&event);
+ isc_mem_putanddetach(&resp->mctx, resp, sizeof(*resp));
want_destroy = exit_check(val);
UNLOCK(&val->lock);
*/
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);
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));
}
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;
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;
.loop = loop,
.cb = cb,
.arg = arg };
- isc_task_attach(task, &val->task);
dns_view_attach(view, &val->view);
isc_mutex_init(&val->lock);
cleanup:
isc_mutex_destroy(&val->lock);
- isc_task_detach(&val->task);
isc_mem_putanddetach(&vstat->mctx, vstat, sizeof(*vstat));
dns_view_detach(&val->view);
}
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);
}
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);
}
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) {
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;
}
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
* 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;
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);
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);
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);
*/
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);
}
/*
* 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 */
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 */
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);
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,
}
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
}
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);
}
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);
}
/*
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;
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();
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);
* 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);
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;
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);
}
}
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);
* 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) {
/*
* 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;
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;
}
/*
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)) {
/*
/*
* 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;
/*
}
UNLOCK(&client->query.fetchlock);
- SAVE(fetch, devent->fetch);
+ SAVE(fetch, resp->fetch);
/*
* We're done recursing, detach from quota and unlink from
/*
* 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) {
/*
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));
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.
/*
* 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);
} 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);
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;
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);
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 */
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);
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);
}
projects / thirdparty / bind9.git / commitdiff
