mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-08-25 03:27:18 +00:00
Code Issues Releases Wiki Activity

refactor dns_request to use loopmgr callbacks

Browse Source 
dns_request_create() and _createraw() now take a 'loop' parameter
and run the callback event on the specified loop.

as the task manager is no longer used, it has been removed from
the dns_requestmgr structure.  the dns_resolver_taskmgr() function
is also no longer used and has been removed.
This commit is contained in:
Evan Hunt 2022-10-25 22:56:48 -07:00 committed by Ondřej Surý
parent d3e2b680d0
commit 106da9c190
No known key found for this signature in database
GPG Key ID: 2820F37E873DEA41
11 changed files with 273 additions and 419 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
bin/nsupdate/nsupdate.c
View File

@ -25,7 +25,6 @@
#include <isc/base64.h> #include <isc/base64.h>
#include <isc/buffer.h> #include <isc/buffer.h>
#include <isc/commandline.h> #include <isc/commandline.h>
#include <isc/event.h>
#include <isc/file.h> #include <isc/file.h>
#include <isc/hash.h> #include <isc/hash.h>
#include <isc/job.h> #include <isc/job.h>
@ -44,7 +43,6 @@
#include <isc/sockaddr.h> #include <isc/sockaddr.h>
#include <isc/stdio.h> #include <isc/stdio.h>
#include <isc/string.h> #include <isc/string.h>
#include <isc/task.h>
#include <isc/tls.h> #include <isc/tls.h>
#include <isc/types.h> #include <isc/types.h>
#include <isc/util.h> #include <isc/util.h>
@ -52,7 +50,6 @@
#include <dns/callbacks.h> #include <dns/callbacks.h>
#include <dns/dispatch.h> #include <dns/dispatch.h>
#include <dns/dnssec.h> #include <dns/dnssec.h>
#include <dns/events.h>
#include <dns/fixedname.h> #include <dns/fixedname.h>
#include <dns/log.h> #include <dns/log.h>
#include <dns/masterdump.h> #include <dns/masterdump.h>
@ -130,7 +127,6 @@ static bool local_only = false;
static isc_nm_t *netmgr = NULL; static isc_nm_t *netmgr = NULL;
static isc_taskmgr_t *taskmgr = NULL; static isc_taskmgr_t *taskmgr = NULL;
static isc_loopmgr_t *loopmgr = NULL; static isc_loopmgr_t *loopmgr = NULL;
static isc_task_t *global_task = NULL;
static isc_log_t *glctx = NULL; static isc_log_t *glctx = NULL;
static isc_mem_t *gmctx = NULL; static isc_mem_t *gmctx = NULL;
static dns_dispatchmgr_t *dispatchmgr = NULL; static dns_dispatchmgr_t *dispatchmgr = NULL;
@ -233,7 +229,7 @@ static void
send_gssrequest(isc_sockaddr_t *destaddr, dns_message_t *msg, send_gssrequest(isc_sockaddr_t *destaddr, dns_message_t *msg,
dns_request_t **request, gss_ctx_id_t context); dns_request_t **request, gss_ctx_id_t context);
static void static void
recvgss(isc_task_t *task, isc_event_t *event); recvgss(void *arg);
#endif /* HAVE_GSSAPI */ #endif /* HAVE_GSSAPI */
static void static void
@ -942,9 +938,6 @@ setup_system(void) {
result = dns_dispatchmgr_create(gmctx, netmgr, &dispatchmgr); result = dns_dispatchmgr_create(gmctx, netmgr, &dispatchmgr);
check_result(result, "dns_dispatchmgr_create"); check_result(result, "dns_dispatchmgr_create");
result = isc_task_create(taskmgr, &global_task, 0);
check_result(result, "isc_task_create");
result = dst_lib_init(gmctx, NULL); result = dst_lib_init(gmctx, NULL);
check_result(result, "dst_lib_init"); check_result(result, "dst_lib_init");
is_dst_up = true; is_dst_up = true;
@ -990,7 +983,7 @@ setup_system(void) {
dns_transport_set_always_verify_remote(transport, dns_transport_set_always_verify_remote(transport,
tls_always_verify_remote); tls_always_verify_remote);
result = dns_requestmgr_create(gmctx, taskmgr, dispatchmgr, dispatchv4, result = dns_requestmgr_create(gmctx, dispatchmgr, dispatchv4,
dispatchv6, &requestmgr); dispatchv6, &requestmgr);
check_result(result, "dns_requestmgr_create"); check_result(result, "dns_requestmgr_create");
@ -2476,32 +2469,24 @@ next_primary(const char *caller, isc_sockaddr_t *addr, isc_result_t eresult) {
} }
static void static void
update_completed(isc_task_t *task, isc_event_t *event) { update_completed(void *arg) {
dns_requestevent_t *reqev = NULL; dns_request_t *request = (dns_request_t *)arg;
isc_result_t result; isc_result_t result;
dns_request_t *request;
UNUSED(task);
ddebug("update_completed()"); ddebug("update_completed()");
requests--; requests--;
REQUIRE(event->ev_type == DNS_EVENT_REQUESTDONE);
reqev = (dns_requestevent_t *)event;
request = reqev->request;
if (shuttingdown) { if (shuttingdown) {
dns_request_destroy(&request); dns_request_destroy(&request);
isc_event_free(&event);
maybeshutdown(); maybeshutdown();
return; return;
} }
if (reqev->result != ISC_R_SUCCESS) { result = dns_request_getresult(request);
if (result != ISC_R_SUCCESS) {
if (!next_primary("update_completed", if (!next_primary("update_completed",
&primary_servers[primary_inuse], &primary_servers[primary_inuse], result))
reqev->result))
{ {
seenerror = true; seenerror = true;
goto done; goto done;
@ -2512,7 +2497,6 @@ update_completed(isc_task_t *task, isc_event_t *event) {
dns_message_renderreset(updatemsg); dns_message_renderreset(updatemsg);
dns_message_settsigkey(updatemsg, NULL); dns_message_settsigkey(updatemsg, NULL);
send_update(zname, &primary_servers[primary_inuse]); send_update(zname, &primary_servers[primary_inuse]);
isc_event_free(&event);
return; return;
} }
@ -2583,7 +2567,6 @@ done:
dns_name_init(&tmpzonename, 0); dns_name_init(&tmpzonename, 0);
dns_name_init(&restart_primary, 0); dns_name_init(&restart_primary, 0);
} }
isc_event_free(&event);
done_update(); done_update();
} }
@ -2630,10 +2613,11 @@ send_update(dns_name_t *zone, isc_sockaddr_t *primary) {
updatemsg->tsigname->attributes.nocompress = true; updatemsg->tsigname->attributes.nocompress = true;
} }
result = dns_request_create( result = dns_request_create(requestmgr, updatemsg, srcaddr, primary,
requestmgr, updatemsg, srcaddr, primary, req_transport, req_transport, req_tls_ctx_cache, options,
req_tls_ctx_cache, options, tsigkey, timeout, udp_timeout, tsigkey, timeout, udp_timeout, udp_retries,
udp_retries, global_task, update_completed, NULL, &request); isc_loop_main(loopmgr), update_completed,
NULL, &request);
check_result(result, "dns_request_create"); check_result(result, "dns_request_create");
if (debugging) { if (debugging) {
@ -2658,10 +2642,11 @@ next_server(const char *caller, isc_sockaddr_t *addr, isc_result_t eresult) {
} }
static void static void
recvsoa(isc_task_t *task, isc_event_t *event) { recvsoa(void *arg) {
dns_requestevent_t *reqev = NULL; dns_request_t *request = (dns_request_t *)arg;
dns_request_t *request = NULL; isc_result_t result, eresult = dns_request_getresult(request);
isc_result_t result, eresult; nsu_requestinfo_t *reqinfo = dns_request_getarg(request);
dns_message_t *soaquery = reqinfo->msg;
dns_message_t *rcvmsg = NULL; dns_message_t *rcvmsg = NULL;
dns_section_t section; dns_section_t section;
dns_name_t *name = NULL; dns_name_t *name = NULL;
@ -2670,33 +2655,20 @@ recvsoa(isc_task_t *task, isc_event_t *event) {
dns_rdata_t soarr = DNS_RDATA_INIT; dns_rdata_t soarr = DNS_RDATA_INIT;
int pass = 0; int pass = 0;
dns_name_t primary; dns_name_t primary;
nsu_requestinfo_t *reqinfo; isc_sockaddr_t *addr = reqinfo->addr;
dns_message_t *soaquery = NULL; isc_sockaddr_t *srcaddr = NULL;
isc_sockaddr_t *addr;
isc_sockaddr_t *srcaddr;
bool seencname = false; bool seencname = false;
dns_name_t tname; dns_name_t tname;
unsigned int nlabels; unsigned int nlabels;
UNUSED(task);
ddebug("recvsoa()"); ddebug("recvsoa()");
requests--; requests--;
REQUIRE(event->ev_type == DNS_EVENT_REQUESTDONE);
reqev = (dns_requestevent_t *)event;
request = reqev->request;
eresult = reqev->result;
reqinfo = reqev->ev_arg;
soaquery = reqinfo->msg;
addr = reqinfo->addr;
if (shuttingdown) { if (shuttingdown) {
dns_request_destroy(&request); dns_request_destroy(&request);
dns_message_detach(&soaquery); dns_message_detach(&soaquery);
isc_mem_put(gmctx, reqinfo, sizeof(nsu_requestinfo_t)); isc_mem_put(gmctx, reqinfo, sizeof(nsu_requestinfo_t));
isc_event_free(&event);
maybeshutdown(); maybeshutdown();
return; return;
} }
@ -2709,15 +2681,12 @@ recvsoa(isc_task_t *task, isc_event_t *event) {
dns_message_settsigkey(soaquery, NULL); dns_message_settsigkey(soaquery, NULL);
sendrequest(&servers[ns_inuse], soaquery, &request); sendrequest(&servers[ns_inuse], soaquery, &request);
isc_mem_put(gmctx, reqinfo, sizeof(nsu_requestinfo_t)); isc_mem_put(gmctx, reqinfo, sizeof(nsu_requestinfo_t));
isc_event_free(&event);
setzoneclass(dns_rdataclass_none); setzoneclass(dns_rdataclass_none);
return; return;
} }
isc_mem_put(gmctx, reqinfo, sizeof(nsu_requestinfo_t)); isc_mem_put(gmctx, reqinfo, sizeof(nsu_requestinfo_t));
reqinfo = NULL; reqinfo = NULL;
isc_event_free(&event);
reqev = NULL;
ddebug("About to create rcvmsg"); ddebug("About to create rcvmsg");
dns_message_create(gmctx, DNS_MESSAGE_INTENTPARSE, &rcvmsg); dns_message_create(gmctx, DNS_MESSAGE_INTENTPARSE, &rcvmsg);
@ -2751,11 +2720,11 @@ recvsoa(isc_task_t *task, isc_event_t *event) {
srcaddr = localaddr4; srcaddr = localaddr4;
} }
result = dns_request_create(requestmgr, soaquery, srcaddr, addr, result = dns_request_create(
req_transport, req_tls_ctx_cache, requestmgr, soaquery, srcaddr, addr, req_transport,
options, NULL, FIND_TIMEOUT * 20, req_tls_ctx_cache, options, NULL, FIND_TIMEOUT * 20,
FIND_TIMEOUT, 3, global_task, FIND_TIMEOUT, 3, isc_loop_main(loopmgr), recvsoa,
recvsoa, reqinfo, &request); reqinfo, &request);
check_result(result, "dns_request_create"); check_result(result, "dns_request_create");
requests++; requests++;
return; return;
@ -2988,11 +2957,11 @@ sendrequest(isc_sockaddr_t *destaddr, dns_message_t *msg,
srcaddr = localaddr4; srcaddr = localaddr4;
} }
result = dns_request_create(requestmgr, msg, srcaddr, destaddr, result = dns_request_create(
req_transport, req_tls_ctx_cache, options, requestmgr, msg, srcaddr, destaddr, req_transport,
default_servers ? NULL : tsigkey, req_tls_ctx_cache, options, default_servers ? NULL : tsigkey,
FIND_TIMEOUT * 20, FIND_TIMEOUT, 3, FIND_TIMEOUT * 20, FIND_TIMEOUT, 3, isc_loop_main(loopmgr),
global_task, recvsoa, reqinfo, request); recvsoa, reqinfo, request);
check_result(result, "dns_request_create"); check_result(result, "dns_request_create");
requests++; requests++;
} }
@ -3171,8 +3140,8 @@ static void
send_gssrequest(isc_sockaddr_t *destaddr, dns_message_t *msg, send_gssrequest(isc_sockaddr_t *destaddr, dns_message_t *msg,
dns_request_t **request, gss_ctx_id_t context) { dns_request_t **request, gss_ctx_id_t context) {
isc_result_t result; isc_result_t result;
nsu_gssinfo_t *reqinfo; nsu_gssinfo_t *reqinfo = NULL;
isc_sockaddr_t *srcaddr; isc_sockaddr_t *srcaddr = NULL;
unsigned int options = DNS_REQUESTOPT_CASE | DNS_REQUESTOPT_TCP; unsigned int options = DNS_REQUESTOPT_CASE | DNS_REQUESTOPT_TCP;
dns_transport_t *req_transport = NULL; dns_transport_t *req_transport = NULL;
isc_tlsctx_cache_t *req_tls_ctx_cache = NULL; isc_tlsctx_cache_t *req_tls_ctx_cache = NULL;
@ -3186,9 +3155,11 @@ send_gssrequest(isc_sockaddr_t *destaddr, dns_message_t *msg,
REQUIRE(destaddr != NULL); REQUIRE(destaddr != NULL);
reqinfo = isc_mem_get(gmctx, sizeof(nsu_gssinfo_t)); reqinfo = isc_mem_get(gmctx, sizeof(nsu_gssinfo_t));
reqinfo->msg = msg; *reqinfo = (nsu_gssinfo_t){
reqinfo->addr = destaddr; .msg = msg,
reqinfo->context = context; .addr = destaddr,
.context = context,
};
if (isc_sockaddr_pf(destaddr) == AF_INET6) { if (isc_sockaddr_pf(destaddr) == AF_INET6) {
srcaddr = localaddr6; srcaddr = localaddr6;
@ -3199,7 +3170,8 @@ send_gssrequest(isc_sockaddr_t *destaddr, dns_message_t *msg,
result = dns_request_create(requestmgr, msg, srcaddr, destaddr, result = dns_request_create(requestmgr, msg, srcaddr, destaddr,
req_transport, req_tls_ctx_cache, options, req_transport, req_tls_ctx_cache, options,
tsigkey, FIND_TIMEOUT * 20, FIND_TIMEOUT, 3, tsigkey, FIND_TIMEOUT * 20, FIND_TIMEOUT, 3,
global_task, recvgss, reqinfo, request); isc_loop_main(loopmgr), recvgss, reqinfo,
request);
check_result(result, "dns_request_create"); check_result(result, "dns_request_create");
if (debugging) { if (debugging) {
show_message(stdout, msg, "Outgoing update query:"); show_message(stdout, msg, "Outgoing update query:");
@ -3208,40 +3180,27 @@ send_gssrequest(isc_sockaddr_t *destaddr, dns_message_t *msg,
} }
static void static void
recvgss(isc_task_t *task, isc_event_t *event) { recvgss(void *arg) {
dns_requestevent_t *reqev = NULL; dns_request_t *request = (dns_request_t *)arg;
dns_request_t *request = NULL; nsu_gssinfo_t *reqinfo = dns_request_getarg(request);
isc_result_t result, eresult; isc_result_t result, eresult = dns_request_getresult(request);
dns_message_t *rcvmsg = NULL; dns_message_t *rcvmsg = NULL;
nsu_gssinfo_t *reqinfo; dns_message_t *tsigquery = reqinfo->msg;
dns_message_t *tsigquery = NULL; dns_gss_ctx_id_t context = reqinfo->context;
isc_sockaddr_t *addr; isc_sockaddr_t *addr = reqinfo->addr;
dns_gss_ctx_id_t context;
isc_buffer_t buf; isc_buffer_t buf;
dns_name_t *servname; dns_name_t *servname = NULL;
dns_fixedname_t fname; dns_fixedname_t fname;
char *err_message = NULL; char *err_message = NULL;
UNUSED(task);
ddebug("recvgss()"); ddebug("recvgss()");
requests--; requests--;
REQUIRE(event->ev_type == DNS_EVENT_REQUESTDONE);
reqev = (dns_requestevent_t *)event;
request = reqev->request;
eresult = reqev->result;
reqinfo = reqev->ev_arg;
tsigquery = reqinfo->msg;
context = reqinfo->context;
addr = reqinfo->addr;
if (shuttingdown) { if (shuttingdown) {
dns_request_destroy(&request); dns_request_destroy(&request);
dns_message_detach(&tsigquery); dns_message_detach(&tsigquery);
isc_mem_put(gmctx, reqinfo, sizeof(nsu_gssinfo_t)); isc_mem_put(gmctx, reqinfo, sizeof(nsu_gssinfo_t));
isc_event_free(&event);
maybeshutdown(); maybeshutdown();
return; return;
} }
@ -3259,14 +3218,10 @@ recvgss(isc_task_t *task, isc_event_t *event) {
send_gssrequest(kserver, tsigquery, &request, context); send_gssrequest(kserver, tsigquery, &request, context);
} }
isc_mem_put(gmctx, reqinfo, sizeof(nsu_gssinfo_t)); isc_mem_put(gmctx, reqinfo, sizeof(nsu_gssinfo_t));
isc_event_free(&event);
return; return;
} }
isc_mem_put(gmctx, reqinfo, sizeof(nsu_gssinfo_t)); isc_mem_put(gmctx, reqinfo, sizeof(nsu_gssinfo_t));
isc_event_free(&event);
reqev = NULL;
ddebug("recvgss creating rcvmsg"); ddebug("recvgss creating rcvmsg");
dns_message_create(gmctx, DNS_MESSAGE_INTENTPARSE, &rcvmsg); dns_message_create(gmctx, DNS_MESSAGE_INTENTPARSE, &rcvmsg);
@ -3543,7 +3498,6 @@ getinput(void *arg) {
more = user_interaction(); more = user_interaction();
isc_loopmgr_nonblocking(loopmgr); isc_loopmgr_nonblocking(loopmgr);
if (!more) { if (!more) {
isc_task_detach(&global_task);
isc_loopmgr_shutdown(loopmgr); isc_loopmgr_shutdown(loopmgr);
return; return;
} }

47
bin/tests/system/pipelined/pipequeries.c
View File

@ -67,29 +67,24 @@ static isc_sockaddr_t dstaddr;
static int onfly; static int onfly;
static void static void
recvresponse(isc_task_t *task, isc_event_t *event) { recvresponse(void *arg) {
dns_requestevent_t *reqev = (dns_requestevent_t *)event;
isc_result_t result; isc_result_t result;
dns_message_t *query = NULL; dns_request_t *request = (dns_request_t *)arg;
dns_message_t *query = dns_request_getarg(request);
dns_message_t *response = NULL; dns_message_t *response = NULL;
isc_buffer_t outbuf; isc_buffer_t outbuf;
char output[1024]; char output[1024];
UNUSED(task); result = dns_request_getresult(request);
if (result != ISC_R_SUCCESS) {
REQUIRE(reqev != NULL);
if (reqev->result != ISC_R_SUCCESS) {
fprintf(stderr, "I:request event result: %s\n", fprintf(stderr, "I:request event result: %s\n",
isc_result_totext(reqev->result)); isc_result_totext(result));
exit(-1); exit(-1);
} }
query = reqev->ev_arg;
dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &response); dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &response);
result = dns_request_getresponse(reqev->request, response, result = dns_request_getresponse(request, response,
DNS_MESSAGEPARSE_PRESERVEORDER); DNS_MESSAGEPARSE_PRESERVEORDER);
CHECK("dns_request_getresponse", result); CHECK("dns_request_getresponse", result);
@ -115,18 +110,16 @@ recvresponse(isc_task_t *task, isc_event_t *event) {
dns_message_detach(&query); dns_message_detach(&query);
dns_message_detach(&response); dns_message_detach(&response);
dns_request_destroy(&reqev->request); dns_request_destroy(&request);
isc_event_free(&event);
if (--onfly == 0) { if (--onfly == 0) {
isc_task_detach(&task);
isc_loopmgr_shutdown(loopmgr); isc_loopmgr_shutdown(loopmgr);
} }
return; return;
} }
static isc_result_t static isc_result_t
sendquery(isc_task_t *task) { sendquery(void) {
dns_request_t *request = NULL; dns_request_t *request = NULL;
dns_message_t *message = NULL; dns_message_t *message = NULL;
dns_name_t *qname = NULL; dns_name_t *qname = NULL;
@ -168,10 +161,10 @@ sendquery(isc_task_t *task) {
ISC_LIST_APPEND(qname->list, qrdataset, link); ISC_LIST_APPEND(qname->list, qrdataset, link);
dns_message_addname(message, qname, DNS_SECTION_QUESTION); dns_message_addname(message, qname, DNS_SECTION_QUESTION);
result = dns_request_create(requestmgr, message, result = dns_request_create(
have_src ? &srcaddr : NULL, &dstaddr, NULL, requestmgr, message, have_src ? &srcaddr : NULL, &dstaddr, NULL,
NULL, DNS_REQUESTOPT_TCP, NULL, TIMEOUT, 0, NULL, DNS_REQUESTOPT_TCP, NULL, TIMEOUT, 0, 0,
0, task, recvresponse, message, &request); isc_loop_main(loopmgr), recvresponse, message, &request);
CHECK("dns_request_create", result); CHECK("dns_request_create", result);
return (ISC_R_SUCCESS); return (ISC_R_SUCCESS);
@ -179,15 +172,15 @@ sendquery(isc_task_t *task) {
static void static void
sendqueries(void *arg) { sendqueries(void *arg) {
isc_task_t *task = (isc_task_t *)arg;
isc_result_t result; isc_result_t result;
UNUSED(arg);
do { do {
result = sendquery(task); result = sendquery();
} while (result == ISC_R_SUCCESS); } while (result == ISC_R_SUCCESS);
if (onfly == 0) { if (onfly == 0) {
isc_task_detach(&task);
isc_loopmgr_shutdown(loopmgr); isc_loopmgr_shutdown(loopmgr);
} }
return; return;
@ -202,7 +195,6 @@ main(int argc, char *argv[]) {
isc_logconfig_t *lcfg = NULL; isc_logconfig_t *lcfg = NULL;
isc_nm_t *netmgr = NULL; isc_nm_t *netmgr = NULL;
isc_taskmgr_t *taskmgr = NULL; isc_taskmgr_t *taskmgr = NULL;
isc_task_t *task = NULL;
dns_dispatchmgr_t *dispatchmgr = NULL; dns_dispatchmgr_t *dispatchmgr = NULL;
dns_dispatch_t *dispatchv4 = NULL; dns_dispatch_t *dispatchv4 = NULL;
dns_view_t *view = NULL; dns_view_t *view = NULL;
@ -261,17 +253,16 @@ main(int argc, char *argv[]) {
RUNCHECK(dst_lib_init(mctx, NULL)); RUNCHECK(dst_lib_init(mctx, NULL));
RUNCHECK(isc_task_create(taskmgr, &task, 0));
RUNCHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr)); RUNCHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr));
RUNCHECK(dns_dispatch_createudp( RUNCHECK(dns_dispatch_createudp(
dispatchmgr, have_src ? &srcaddr : &bind_any, &dispatchv4)); dispatchmgr, have_src ? &srcaddr : &bind_any, &dispatchv4));
RUNCHECK(dns_requestmgr_create(mctx, taskmgr, dispatchmgr, dispatchv4, RUNCHECK(dns_requestmgr_create(mctx, dispatchmgr, dispatchv4, NULL,
NULL, &requestmgr)); &requestmgr));
RUNCHECK(dns_view_create(mctx, 0, "_test", &view)); RUNCHECK(dns_view_create(mctx, 0, "_test", &view));
isc_loopmgr_setup(loopmgr, sendqueries, task); isc_loopmgr_setup(loopmgr, sendqueries, NULL);
isc_loopmgr_run(loopmgr); isc_loopmgr_run(loopmgr);
dns_view_detach(&view); dns_view_detach(&view);

39
bin/tests/system/tkey/keycreate.c
View File

@ -66,29 +66,25 @@ static dns_requestmgr_t *requestmgr = NULL;
static const char *ownername_str = "."; static const char *ownername_str = ".";
static void static void
recvquery(isc_task_t *task, isc_event_t *event) { recvquery(void *arg) {
dns_requestevent_t *reqev = (dns_requestevent_t *)event; dns_request_t *request = (dns_request_t *)arg;
dns_message_t *query = dns_request_getarg(request);
dns_message_t *response = NULL;
isc_result_t result; isc_result_t result;
dns_message_t *query = NULL, *response = NULL;
char keyname[256]; char keyname[256];
isc_buffer_t keynamebuf; isc_buffer_t keynamebuf;
int type; int type;
UNUSED(task); result = dns_request_getresult(request);
if (result != ISC_R_SUCCESS) {
REQUIRE(reqev != NULL);
if (reqev->result != ISC_R_SUCCESS) {
fprintf(stderr, "I:request event result: %s\n", fprintf(stderr, "I:request event result: %s\n",
isc_result_totext(reqev->result)); isc_result_totext(result));
exit(-1); exit(-1);
} }
query = reqev->ev_arg;
dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &response); dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &response);
result = dns_request_getresponse(reqev->request, response, result = dns_request_getresponse(request, response,
DNS_MESSAGEPARSE_PRESERVEORDER); DNS_MESSAGEPARSE_PRESERVEORDER);
CHECK("dns_request_getresponse", result); CHECK("dns_request_getresponse", result);
@ -117,15 +113,12 @@ recvquery(isc_task_t *task, isc_event_t *event) {
dns_message_detach(&query); dns_message_detach(&query);
dns_message_detach(&response); dns_message_detach(&response);
dns_request_destroy(&reqev->request); dns_request_destroy(&request);
isc_event_free(&event);
isc_task_detach(&task);
isc_loopmgr_shutdown(loopmgr); isc_loopmgr_shutdown(loopmgr);
} }
static void static void
sendquery(void *arg) { sendquery(void *arg) {
isc_task_t *task = (isc_task_t *)arg;
struct in_addr inaddr; struct in_addr inaddr;
isc_sockaddr_t address; isc_sockaddr_t address;
isc_region_t r; isc_region_t r;
@ -138,6 +131,8 @@ sendquery(void *arg) {
dns_request_t *request = NULL; dns_request_t *request = NULL;
static char keystr[] = "0123456789ab"; static char keystr[] = "0123456789ab";
UNUSED(arg);
result = ISC_R_FAILURE; result = ISC_R_FAILURE;
if (inet_pton(AF_INET, ip_address, &inaddr) != 1) { if (inet_pton(AF_INET, ip_address, &inaddr) != 1) {
CHECK("inet_pton", result); CHECK("inet_pton", result);
@ -179,8 +174,8 @@ sendquery(void *arg) {
result = dns_request_create(requestmgr, query, NULL, &address, NULL, result = dns_request_create(requestmgr, query, NULL, &address, NULL,
NULL, DNS_REQUESTOPT_TCP, initialkey, NULL, DNS_REQUESTOPT_TCP, initialkey,
TIMEOUT, 0, 0, task, recvquery, query, TIMEOUT, 0, 0, isc_loop_main(loopmgr),
&request); recvquery, query, &request);
CHECK("dns_request_create", result); CHECK("dns_request_create", result);
} }
@ -196,7 +191,6 @@ main(int argc, char *argv[]) {
dns_tkeyctx_t *tctx = NULL; dns_tkeyctx_t *tctx = NULL;
isc_log_t *log = NULL; isc_log_t *log = NULL;
isc_logconfig_t *logconfig = NULL; isc_logconfig_t *logconfig = NULL;
isc_task_t *task = NULL;
isc_result_t result; isc_result_t result;
int type; int type;
@ -220,13 +214,12 @@ main(int argc, char *argv[]) {
RUNCHECK(dst_lib_init(mctx, NULL)); RUNCHECK(dst_lib_init(mctx, NULL));
RUNCHECK(isc_task_create(taskmgr, &task, 0));
RUNCHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr)); RUNCHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr));
isc_sockaddr_any(&bind_any); isc_sockaddr_any(&bind_any);
RUNCHECK(dns_dispatch_createudp(dispatchmgr, &bind_any, &dispatchv4)); RUNCHECK(dns_dispatch_createudp(dispatchmgr, &bind_any, &dispatchv4));
RUNCHECK(dns_requestmgr_create(mctx, taskmgr, dispatchmgr, dispatchv4, RUNCHECK(dns_requestmgr_create(mctx, dispatchmgr, dispatchv4, NULL,
NULL, &requestmgr)); &requestmgr));
RUNCHECK(dns_tsigkeyring_create(mctx, &ring)); RUNCHECK(dns_tsigkeyring_create(mctx, &ring));
RUNCHECK(dns_tkeyctx_create(mctx, &tctx)); RUNCHECK(dns_tkeyctx_create(mctx, &tctx));
@ -243,7 +236,7 @@ main(int argc, char *argv[]) {
isc_nonce_buf(noncedata, sizeof(noncedata)); isc_nonce_buf(noncedata, sizeof(noncedata));
isc_buffer_add(&nonce, sizeof(noncedata)); isc_buffer_add(&nonce, sizeof(noncedata));
isc_loopmgr_setup(loopmgr, sendquery, task); isc_loopmgr_setup(loopmgr, sendquery, NULL);
isc_loopmgr_run(loopmgr); isc_loopmgr_run(loopmgr);
dns_requestmgr_shutdown(requestmgr); dns_requestmgr_shutdown(requestmgr);

38
bin/tests/system/tkey/keydelete.c
View File

@ -60,26 +60,22 @@ static dns_tsig_keyring_t *ring = NULL;
static dns_requestmgr_t *requestmgr = NULL; static dns_requestmgr_t *requestmgr = NULL;
static void static void
recvquery(isc_task_t *task, isc_event_t *event) { recvquery(void *arg) {
dns_requestevent_t *reqev = (dns_requestevent_t *)event;
isc_result_t result; isc_result_t result;
dns_message_t *query = NULL, *response = NULL; dns_request_t *request = (dns_request_t *)arg;
dns_message_t *query = dns_request_getarg(request);
dns_message_t *response = NULL;
UNUSED(task); result = dns_request_getresult(request);
if (result != ISC_R_SUCCESS) {
REQUIRE(reqev != NULL);
if (reqev->result != ISC_R_SUCCESS) {
fprintf(stderr, "I:request event result: %s\n", fprintf(stderr, "I:request event result: %s\n",
isc_result_totext(reqev->result)); isc_result_totext(result));
exit(-1); exit(-1);
} }
query = reqev->ev_arg;
dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &response); dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &response);
result = dns_request_getresponse(reqev->request, response, result = dns_request_getresponse(request, response,
DNS_MESSAGEPARSE_PRESERVEORDER); DNS_MESSAGEPARSE_PRESERVEORDER);
CHECK("dns_request_getresponse", result); CHECK("dns_request_getresponse", result);
@ -95,21 +91,20 @@ recvquery(isc_task_t *task, isc_event_t *event) {
dns_message_detach(&query); dns_message_detach(&query);
dns_message_detach(&response); dns_message_detach(&response);
dns_request_destroy(&reqev->request); dns_request_destroy(&request);
isc_event_free(&event);
isc_task_detach(&task);
isc_loopmgr_shutdown(loopmgr); isc_loopmgr_shutdown(loopmgr);
} }
static void static void
sendquery(void *arg) { sendquery(void *arg) {
isc_task_t *task = (isc_task_t *)arg;
struct in_addr inaddr; struct in_addr inaddr;
isc_sockaddr_t address; isc_sockaddr_t address;
isc_result_t result; isc_result_t result;
dns_message_t *query = NULL; dns_message_t *query = NULL;
dns_request_t *request = NULL; dns_request_t *request = NULL;
UNUSED(arg);
result = ISC_R_FAILURE; result = ISC_R_FAILURE;
if (inet_pton(AF_INET, ip_address, &inaddr) != 1) { if (inet_pton(AF_INET, ip_address, &inaddr) != 1) {
CHECK("inet_pton", result); CHECK("inet_pton", result);
@ -123,7 +118,8 @@ sendquery(void *arg) {
result = dns_request_create(requestmgr, query, NULL, &address, NULL, result = dns_request_create(requestmgr, query, NULL, &address, NULL,
NULL, DNS_REQUESTOPT_TCP, tsigkey, TIMEOUT, NULL, DNS_REQUESTOPT_TCP, tsigkey, TIMEOUT,
0, 0, task, recvquery, query, &request); 0, 0, isc_loop_main(loopmgr), recvquery,
query, &request);
CHECK("dns_request_create", result); CHECK("dns_request_create", result);
} }
@ -140,7 +136,6 @@ main(int argc, char **argv) {
dst_key_t *dstkey = NULL; dst_key_t *dstkey = NULL;
isc_log_t *log = NULL; isc_log_t *log = NULL;
isc_logconfig_t *logconfig = NULL; isc_logconfig_t *logconfig = NULL;
isc_task_t *task = NULL;
isc_result_t result; isc_result_t result;
int type; int type;
@ -162,12 +157,11 @@ main(int argc, char **argv) {
RUNCHECK(dst_lib_init(mctx, NULL)); RUNCHECK(dst_lib_init(mctx, NULL));
RUNCHECK(isc_task_create(taskmgr, &task, 0));
RUNCHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr)); RUNCHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr));
isc_sockaddr_any(&bind_any); isc_sockaddr_any(&bind_any);
RUNCHECK(dns_dispatch_createudp(dispatchmgr, &bind_any, &dispatchv4)); RUNCHECK(dns_dispatch_createudp(dispatchmgr, &bind_any, &dispatchv4));
RUNCHECK(dns_requestmgr_create(mctx, taskmgr, dispatchmgr, dispatchv4, RUNCHECK(dns_requestmgr_create(mctx, dispatchmgr, dispatchv4, NULL,
NULL, &requestmgr)); &requestmgr));
RUNCHECK(dns_tsigkeyring_create(mctx, &ring)); RUNCHECK(dns_tsigkeyring_create(mctx, &ring));
RUNCHECK(dns_tkeyctx_create(mctx, &tctx)); RUNCHECK(dns_tkeyctx_create(mctx, &tctx));
@ -184,7 +178,7 @@ main(int argc, char **argv) {
dst_key_free(&dstkey); dst_key_free(&dstkey);
CHECK("dns_tsigkey_createfromkey", result); CHECK("dns_tsigkey_createfromkey", result);
isc_loopmgr_setup(loopmgr, sendquery, task); isc_loopmgr_setup(loopmgr, sendquery, NULL);
isc_loopmgr_run(loopmgr); isc_loopmgr_run(loopmgr);
dns_requestmgr_shutdown(requestmgr); dns_requestmgr_shutdown(requestmgr);

31
bin/tools/mdig.c
View File

@ -85,7 +85,6 @@
#define MAXTRIES 0xffffffff #define MAXTRIES 0xffffffff
static isc_mem_t *mctx = NULL; static isc_mem_t *mctx = NULL;
static isc_task_t *global_task = NULL;
static isc_loopmgr_t *loopmgr = NULL; static isc_loopmgr_t *loopmgr = NULL;
static dns_requestmgr_t *requestmgr = NULL; static dns_requestmgr_t *requestmgr = NULL;
static const char *batchname = NULL; static const char *batchname = NULL;
@ -186,8 +185,8 @@ rcode_totext(dns_rcode_t rcode) {
} }
static void static void
recvresponse(isc_task_t *task, isc_event_t *event) { recvresponse(void *arg) {
dns_requestevent_t *reqev = (dns_requestevent_t *)event; dns_request_t *request = (dns_request_t *)arg;
isc_result_t result; isc_result_t result;
dns_message_t *query = NULL, *response = NULL; dns_message_t *query = NULL, *response = NULL;
unsigned int parseflags = 0; unsigned int parseflags = 0;
@ -197,14 +196,12 @@ recvresponse(isc_task_t *task, isc_event_t *event) {
unsigned int styleflags = 0; unsigned int styleflags = 0;
dns_messagetextflag_t flags; dns_messagetextflag_t flags;
UNUSED(task); query = dns_request_getarg(request);
REQUIRE(reqev != NULL); result = dns_request_getresult(request);
query = reqev->ev_arg; if (result != ISC_R_SUCCESS) {
if (reqev->result != ISC_R_SUCCESS) {
fprintf(stderr, "response failed with %s\n", fprintf(stderr, "response failed with %s\n",
isc_result_totext(reqev->result)); isc_result_totext(result));
if (continue_on_error) { if (continue_on_error) {
goto cleanup; goto cleanup;
} else { } else {
@ -220,8 +217,8 @@ recvresponse(isc_task_t *task, isc_event_t *event) {
parseflags |= DNS_MESSAGEPARSE_IGNORETRUNCATION; parseflags |= DNS_MESSAGEPARSE_IGNORETRUNCATION;
} }
msgbuf = dns_request_getanswer(reqev->request); msgbuf = dns_request_getanswer(request);
result = dns_request_getresponse(reqev->request, response, parseflags); result = dns_request_getresponse(request, response, parseflags);
CHECK("dns_request_getresponse", result); CHECK("dns_request_getresponse", result);
styleflags |= DNS_STYLEFLAG_REL_OWNER; styleflags |= DNS_STYLEFLAG_REL_OWNER;
@ -541,11 +538,9 @@ cleanup:
if (response != NULL) { if (response != NULL) {
dns_message_detach(&response); dns_message_detach(&response);
} }
dns_request_destroy(&reqev->request); dns_request_destroy(&request);
isc_event_free(&event);
if (--onfly == 0) { if (--onfly == 0) {
isc_task_detach(&global_task);
isc_loopmgr_shutdown(loopmgr); isc_loopmgr_shutdown(loopmgr);
} }
return; return;
@ -754,8 +749,8 @@ sendquery(struct query *query) {
result = dns_request_create( result = dns_request_create(
requestmgr, message, have_src ? &srcaddr : NULL, &dstaddr, NULL, requestmgr, message, have_src ? &srcaddr : NULL, &dstaddr, NULL,
NULL, options, NULL, query->timeout, query->udptimeout, NULL, options, NULL, query->timeout, query->udptimeout,
query->udpretries, global_task, recvresponse, message, query->udpretries, isc_loop_main(loopmgr), recvresponse,
&request); message, &request);
CHECK("dns_request_create", result); CHECK("dns_request_create", result);
return (ISC_R_SUCCESS); return (ISC_R_SUCCESS);
@ -773,7 +768,6 @@ sendqueries(void *arg) {
} }
if (onfly == 0) { if (onfly == 0) {
isc_task_detach(&global_task);
isc_loopmgr_shutdown(loopmgr); isc_loopmgr_shutdown(loopmgr);
} }
} }
@ -2135,7 +2129,6 @@ main(int argc, char *argv[]) {
fatal("can't choose between IPv4 and IPv6"); fatal("can't choose between IPv4 and IPv6");
} }
RUNCHECK(isc_task_create(taskmgr, &global_task, 0));
RUNCHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr)); RUNCHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr));
set_source_ports(dispatchmgr); set_source_ports(dispatchmgr);
@ -2149,7 +2142,7 @@ main(int argc, char *argv[]) {
dispatchmgr, have_src ? &srcaddr : &bind_any, &dispatchvx)); dispatchmgr, have_src ? &srcaddr : &bind_any, &dispatchvx));
RUNCHECK(dns_requestmgr_create( RUNCHECK(dns_requestmgr_create(
mctx, taskmgr, dispatchmgr, have_ipv4 ? dispatchvx : NULL, mctx, dispatchmgr, have_ipv4 ? dispatchvx : NULL,
have_ipv6 ? dispatchvx : NULL, &requestmgr)); have_ipv6 ? dispatchvx : NULL, &requestmgr));
RUNCHECK(dns_view_create(mctx, 0, "_test", &view)); RUNCHECK(dns_view_create(mctx, 0, "_test", &view));

41
lib/dns/include/dns/request.h
View File

@ -46,17 +46,10 @@
#define DNS_REQUESTOPT_FIXEDID 0x00000004U #define DNS_REQUESTOPT_FIXEDID 0x00000004U
#define DNS_REQUESTOPT_LARGE 0x00000008U #define DNS_REQUESTOPT_LARGE 0x00000008U
typedef struct dns_requestevent {
ISC_EVENT_COMMON(struct dns_requestevent);
isc_result_t result;
dns_request_t *request;
} dns_requestevent_t;
ISC_LANG_BEGINDECLS ISC_LANG_BEGINDECLS
isc_result_t isc_result_t
dns_requestmgr_create(isc_mem_t *mctx, isc_taskmgr_t *taskmgr, dns_requestmgr_create(isc_mem_t *mctx, dns_dispatchmgr_t *dispatchmgr,
dns_dispatchmgr_t *dispatchmgr,
dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6, dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6,
dns_requestmgr_t **requestmgrp); dns_requestmgr_t **requestmgrp);
/*%< /*%<
@ -66,8 +59,6 @@ dns_requestmgr_create(isc_mem_t *mctx, isc_taskmgr_t *taskmgr,
* *
*\li 'mctx' is a valid memory context. *\li 'mctx' is a valid memory context.
* *
*\li 'taskmgr' is a valid task manager.
*
*\li 'dispatchv4' is a valid dispatcher with an IPv4 UDP socket, or is NULL. *\li 'dispatchv4' is a valid dispatcher with an IPv4 UDP socket, or is NULL.
* *
*\li 'dispatchv6' is a valid dispatcher with an IPv6 UDP socket, or is NULL. *\li 'dispatchv6' is a valid dispatcher with an IPv6 UDP socket, or is NULL.
@ -135,7 +126,7 @@ dns_request_create(dns_requestmgr_t *requestmgr, dns_message_t *message,
isc_tlsctx_cache_t *tlsctx_cache, unsigned int options, isc_tlsctx_cache_t *tlsctx_cache, unsigned int options,
dns_tsigkey_t *key, unsigned int timeout, dns_tsigkey_t *key, unsigned int timeout,
unsigned int udptimeout, unsigned int udpretries, unsigned int udptimeout, unsigned int udpretries,
isc_task_t *task, isc_taskaction_t action, void *arg, isc_loop_t *loop, isc_job_cb cb, void *arg,
dns_request_t **requestp); dns_request_t **requestp);
/*%< /*%<
* Create and send a request. * Create and send a request.
@ -156,7 +147,7 @@ dns_request_create(dns_requestmgr_t *requestmgr, dns_message_t *message,
* compression context to accommodate more names. * compression context to accommodate more names.
* *
*\li When the request completes, successfully, due to a timeout, or *\li When the request completes, successfully, due to a timeout, or
* because it was canceled, a completion event will be sent to 'task'. * because it was canceled, a completion callback will run on 'loop'.
* *
* Requires: * Requires:
* *
@ -170,7 +161,7 @@ dns_request_create(dns_requestmgr_t *requestmgr, dns_message_t *message,
* *
*\li 'timeout' > 0 *\li 'timeout' > 0
* *
*\li 'task' is a valid task. *\li 'loop' is a valid loop.
* *
*\li requestp != NULL && *requestp == NULL *\li requestp != NULL && *requestp == NULL
*/ */
@ -182,9 +173,8 @@ dns_request_createraw(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
dns_transport_t *transport, dns_transport_t *transport,
isc_tlsctx_cache_t *tlsctx_cache, unsigned int options, isc_tlsctx_cache_t *tlsctx_cache, unsigned int options,
unsigned int timeout, unsigned int udptimeout, unsigned int timeout, unsigned int udptimeout,
unsigned int udpretries, isc_task_t *task, unsigned int udpretries, isc_loop_t *loop, isc_job_cb cb,
isc_taskaction_t action, void *arg, void *arg, dns_request_t **requestp);
dns_request_t **requestp);
/*!< /*!<
* \brief Create and send a request. * \brief Create and send a request.
* *
@ -198,7 +188,7 @@ dns_request_createraw(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
* at 'udptimeout' intervals if non-zero or if 'udpretries' is not zero. * at 'udptimeout' intervals if non-zero or if 'udpretries' is not zero.
* *
*\li When the request completes, successfully, due to a timeout, or *\li When the request completes, successfully, due to a timeout, or
* because it was canceled, a completion event will be sent to 'task'. * because it was canceled, a completion callback will run in 'loop'.
* *
* Requires: * Requires:
* *
@ -212,7 +202,7 @@ dns_request_createraw(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
* *
*\li 'timeout' > 0 *\li 'timeout' > 0
* *
*\li 'task' is a valid task. *\li 'loop' is a valid loop.
* *
*\li requestp != NULL && *requestp == NULL *\li requestp != NULL && *requestp == NULL
*/ */
@ -299,4 +289,19 @@ dns_request_destroy(dns_request_t **requestp);
*\li *requestp == NULL *\li *requestp == NULL
*/ */
void *
dns_request_getarg(dns_request_t *request);
/*%<
* Return the value of 'arg' that was passed in when 'request' was
* created.
*/
isc_result_t
dns_request_getresult(dns_request_t *request);
/*%<
* Get the result code of 'request'. (This is to be called by the
* completion handler.)
*/
ISC_REFCOUNT_DECL(dns_request);
ISC_LANG_ENDDECLS ISC_LANG_ENDDECLS

3
lib/dns/include/dns/resolver.h
View File

@ -406,9 +406,6 @@ dns_resolver_dispatchv4(dns_resolver_t *resolver);
dns_dispatch_t * dns_dispatch_t *
dns_resolver_dispatchv6(dns_resolver_t *resolver); dns_resolver_dispatchv6(dns_resolver_t *resolver);
isc_taskmgr_t *
dns_resolver_taskmgr(dns_resolver_t *resolver);
uint32_t uint32_t
dns_resolver_getlamettl(dns_resolver_t *resolver); dns_resolver_getlamettl(dns_resolver_t *resolver);
/*%< /*%<

162
lib/dns/request.c
View File

@ -16,11 +16,12 @@
#include <inttypes.h> #include <inttypes.h>
#include <stdbool.h> #include <stdbool.h>
#include <isc/async.h>
#include <isc/loop.h>
#include <isc/magic.h> #include <isc/magic.h>
#include <isc/mem.h> #include <isc/mem.h>
#include <isc/netmgr.h> #include <isc/netmgr.h>
#include <isc/result.h> #include <isc/result.h>
#include <isc/task.h>
#include <isc/thread.h> #include <isc/thread.h>
#include <isc/tls.h> #include <isc/tls.h>
#include <isc/util.h> #include <isc/util.h>
@ -28,7 +29,6 @@
#include <dns/acl.h> #include <dns/acl.h>
#include <dns/compress.h> #include <dns/compress.h>
#include <dns/dispatch.h> #include <dns/dispatch.h>
#include <dns/events.h>
#include <dns/log.h> #include <dns/log.h>
#include <dns/message.h> #include <dns/message.h>
#include <dns/rdata.h> #include <dns/rdata.h>
@ -55,7 +55,6 @@ struct dns_requestmgr {
isc_mem_t *mctx; isc_mem_t *mctx;
/* locked */ /* locked */
isc_taskmgr_t *taskmgr;
dns_dispatchmgr_t *dispatchmgr; dns_dispatchmgr_t *dispatchmgr;
dns_dispatch_t *dispatchv4; dns_dispatch_t *dispatchv4;
dns_dispatch_t *dispatchv6; dns_dispatch_t *dispatchv6;
@ -72,10 +71,14 @@ struct dns_request {
unsigned int hash; unsigned int hash;
isc_mem_t *mctx; isc_mem_t *mctx;
int32_t flags; int32_t flags;
isc_loop_t *loop;
isc_result_t result;
isc_job_cb cb;
void *arg;
bool complete;
ISC_LINK(dns_request_t) link; ISC_LINK(dns_request_t) link;
isc_buffer_t *query; isc_buffer_t *query;
isc_buffer_t *answer; isc_buffer_t *answer;
dns_requestevent_t *event;
dns_dispatch_t *dispatch; dns_dispatch_t *dispatch;
dns_dispentry_t *dispentry; dns_dispentry_t *dispentry;
dns_requestmgr_t *requestmgr; dns_requestmgr_t *requestmgr;
@ -115,10 +118,6 @@ req_sendevent(dns_request_t *request, isc_result_t result);
static void static void
req_connected(isc_result_t eresult, isc_region_t *region, void *arg); req_connected(isc_result_t eresult, isc_region_t *region, void *arg);
static void static void
req_attach(dns_request_t *source, dns_request_t **targetp);
static void
req_detach(dns_request_t **requestp);
static void
req_destroy(dns_request_t *request); req_destroy(dns_request_t *request);
static void static void
req_log(int level, const char *fmt, ...) ISC_FORMAT_PRINTF(2, 3); req_log(int level, const char *fmt, ...) ISC_FORMAT_PRINTF(2, 3);
@ -130,8 +129,7 @@ request_cancel(dns_request_t *request);
***/ ***/
isc_result_t isc_result_t
dns_requestmgr_create(isc_mem_t *mctx, isc_taskmgr_t *taskmgr, dns_requestmgr_create(isc_mem_t *mctx, dns_dispatchmgr_t *dispatchmgr,
dns_dispatchmgr_t *dispatchmgr,
dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6, dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6,
dns_requestmgr_t **requestmgrp) { dns_requestmgr_t **requestmgrp) {
dns_requestmgr_t *requestmgr; dns_requestmgr_t *requestmgr;
@ -140,13 +138,11 @@ dns_requestmgr_create(isc_mem_t *mctx, isc_taskmgr_t *taskmgr,
req_log(ISC_LOG_DEBUG(3), "dns_requestmgr_create"); req_log(ISC_LOG_DEBUG(3), "dns_requestmgr_create");
REQUIRE(requestmgrp != NULL && *requestmgrp == NULL); REQUIRE(requestmgrp != NULL && *requestmgrp == NULL);
REQUIRE(taskmgr != NULL);
REQUIRE(dispatchmgr != NULL); REQUIRE(dispatchmgr != NULL);
requestmgr = isc_mem_get(mctx, sizeof(*requestmgr)); requestmgr = isc_mem_get(mctx, sizeof(*requestmgr));
*requestmgr = (dns_requestmgr_t){ 0 }; *requestmgr = (dns_requestmgr_t){ 0 };
isc_taskmgr_attach(taskmgr, &requestmgr->taskmgr);
dns_dispatchmgr_attach(dispatchmgr, &requestmgr->dispatchmgr); dns_dispatchmgr_attach(dispatchmgr, &requestmgr->dispatchmgr);
isc_mutex_init(&requestmgr->lock); isc_mutex_init(&requestmgr->lock);
@ -259,9 +255,6 @@ mgr_destroy(dns_requestmgr_t *requestmgr) {
if (requestmgr->dispatchmgr != NULL) { if (requestmgr->dispatchmgr != NULL) {
dns_dispatchmgr_detach(&requestmgr->dispatchmgr); dns_dispatchmgr_detach(&requestmgr->dispatchmgr);
} }
if (requestmgr->taskmgr != NULL) {
isc_taskmgr_detach(&requestmgr->taskmgr);
}
requestmgr->magic = 0; requestmgr->magic = 0;
isc_mem_putanddetach(&requestmgr->mctx, requestmgr, isc_mem_putanddetach(&requestmgr->mctx, requestmgr,
sizeof(*requestmgr)); sizeof(*requestmgr));
@ -290,7 +283,7 @@ req_send(dns_request_t *request) {
request->flags |= DNS_REQUEST_F_SENDING; request->flags |= DNS_REQUEST_F_SENDING;
/* detached in req_senddone() */ /* detached in req_senddone() */
req_attach(request, &(dns_request_t *){ NULL }); dns_request_ref(request);
dns_dispatch_send(request->dispentry, &r); dns_dispatch_send(request->dispentry, &r);
} }
@ -410,9 +403,8 @@ dns_request_createraw(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
dns_transport_t *transport, dns_transport_t *transport,
isc_tlsctx_cache_t *tlsctx_cache, unsigned int options, isc_tlsctx_cache_t *tlsctx_cache, unsigned int options,
unsigned int timeout, unsigned int udptimeout, unsigned int timeout, unsigned int udptimeout,
unsigned int udpretries, isc_task_t *task, unsigned int udpretries, isc_loop_t *loop, isc_job_cb cb,
isc_taskaction_t action, void *arg, void *arg, dns_request_t **requestp) {
dns_request_t **requestp) {
dns_request_t *request = NULL; dns_request_t *request = NULL;
isc_result_t result; isc_result_t result;
isc_mem_t *mctx = NULL; isc_mem_t *mctx = NULL;
@ -425,8 +417,8 @@ dns_request_createraw(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
REQUIRE(VALID_REQUESTMGR(requestmgr)); REQUIRE(VALID_REQUESTMGR(requestmgr));
REQUIRE(msgbuf != NULL); REQUIRE(msgbuf != NULL);
REQUIRE(destaddr != NULL); REQUIRE(destaddr != NULL);
REQUIRE(task != NULL); REQUIRE(loop != NULL);
REQUIRE(action != NULL); REQUIRE(cb != NULL);
REQUIRE(requestp != NULL && *requestp == NULL); REQUIRE(requestp != NULL && *requestp == NULL);
REQUIRE(timeout > 0); REQUIRE(timeout > 0);
if (srcaddr != NULL) { if (srcaddr != NULL) {
@ -451,16 +443,12 @@ dns_request_createraw(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
return (result); return (result);
} }
request->loop = loop;
request->cb = cb;
request->arg = arg;
request->result = ISC_R_FAILURE;
request->udpcount = udpretries; request->udpcount = udpretries;
request->event = (dns_requestevent_t *)isc_event_allocate(
mctx, task, DNS_EVENT_REQUESTDONE, action, arg,
sizeof(dns_requestevent_t));
isc_task_attach(task, &(isc_task_t *){ NULL });
request->event->ev_sender = task;
request->event->request = request;
request->event->result = ISC_R_FAILURE;
isc_buffer_usedregion(msgbuf, &r); isc_buffer_usedregion(msgbuf, &r);
if (r.length < DNS_MESSAGE_HEADERLEN || r.length > 65535) { if (r.length < DNS_MESSAGE_HEADERLEN || r.length > 65535) {
result = DNS_R_FORMERR; result = DNS_R_FORMERR;
@ -487,7 +475,7 @@ dns_request_createraw(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
} }
/* detached in req_connected() */ /* detached in req_connected() */
req_attach(request, &(dns_request_t *){ NULL }); dns_request_ref(request);
again: again:
@ -549,13 +537,11 @@ unlink:
UNLOCK(&requestmgr->lock); UNLOCK(&requestmgr->lock);
detach: detach:
/* connect failed, detach here */ /* connect failed, unref here */
req_detach(&(dns_request_t *){ request }); dns_request_unref(request);
cleanup: cleanup:
isc_task_detach(&(isc_task_t *){ task }); dns_request_detach(&request);
/* final detach to shut down request */
req_detach(&request);
req_log(ISC_LOG_DEBUG(3), "dns_request_createraw: failed %s", req_log(ISC_LOG_DEBUG(3), "dns_request_createraw: failed %s",
isc_result_totext(result)); isc_result_totext(result));
return (result); return (result);
@ -568,7 +554,7 @@ dns_request_create(dns_requestmgr_t *requestmgr, dns_message_t *message,
isc_tlsctx_cache_t *tlsctx_cache, unsigned int options, isc_tlsctx_cache_t *tlsctx_cache, unsigned int options,
dns_tsigkey_t *key, unsigned int timeout, dns_tsigkey_t *key, unsigned int timeout,
unsigned int udptimeout, unsigned int udpretries, unsigned int udptimeout, unsigned int udpretries,
isc_task_t *task, isc_taskaction_t action, void *arg, isc_loop_t *loop, isc_job_cb cb, void *arg,
dns_request_t **requestp) { dns_request_t **requestp) {
dns_request_t *request = NULL; dns_request_t *request = NULL;
isc_result_t result; isc_result_t result;
@ -580,8 +566,8 @@ dns_request_create(dns_requestmgr_t *requestmgr, dns_message_t *message,
REQUIRE(VALID_REQUESTMGR(requestmgr)); REQUIRE(VALID_REQUESTMGR(requestmgr));
REQUIRE(message != NULL); REQUIRE(message != NULL);
REQUIRE(destaddr != NULL); REQUIRE(destaddr != NULL);
REQUIRE(task != NULL); REQUIRE(loop != NULL);
REQUIRE(action != NULL); REQUIRE(cb != NULL);
REQUIRE(requestp != NULL && *requestp == NULL); REQUIRE(requestp != NULL && *requestp == NULL);
REQUIRE(timeout > 0); REQUIRE(timeout > 0);
@ -609,15 +595,13 @@ dns_request_create(dns_requestmgr_t *requestmgr, dns_message_t *message,
return (result); return (result);
} }
request->loop = loop;
request->cb = cb;
request->arg = arg;
request->result = ISC_R_FAILURE;
request->udpcount = udpretries; request->udpcount = udpretries;
request->event = (dns_requestevent_t *)isc_event_allocate( request->udpcount = udpretries;
mctx, task, DNS_EVENT_REQUESTDONE, action, arg,
sizeof(dns_requestevent_t));
isc_task_attach(task, &(isc_task_t *){ NULL });
request->event->ev_sender = task;
request->event->request = request;
request->event->result = ISC_R_FAILURE;
if (key != NULL) { if (key != NULL) {
dns_tsigkey_attach(key, &request->tsigkey); dns_tsigkey_attach(key, &request->tsigkey);
@ -642,7 +626,7 @@ dns_request_create(dns_requestmgr_t *requestmgr, dns_message_t *message,
} }
/* detached in req_connected() */ /* detached in req_connected() */
req_attach(request, &(dns_request_t *){ NULL }); dns_request_ref(request);
again: again:
result = get_dispatch(tcp, false, requestmgr, srcaddr, destaddr, result = get_dispatch(tcp, false, requestmgr, srcaddr, destaddr,
@ -691,8 +675,8 @@ again:
if (tcp && connected) { if (tcp && connected) {
req_send(request); req_send(request);
/* no need to call req_connected(), detach here */ /* no need to call req_connected(), unref here */
req_detach(&(dns_request_t *){ request }); dns_request_unref(request);
} else { } else {
request->flags |= DNS_REQUEST_F_CONNECTING; request->flags |= DNS_REQUEST_F_CONNECTING;
if (tcp) { if (tcp) {
@ -715,13 +699,11 @@ unlink:
UNLOCK(&requestmgr->lock); UNLOCK(&requestmgr->lock);
detach: detach:
/* connect failed, detach here */ /* connect failed, unref here */
req_detach(&(dns_request_t *){ request }); dns_request_unref(request);
cleanup: cleanup:
isc_task_detach(&(isc_task_t *){ task }); dns_request_detach(&request);
/* final detach to shut down request */
req_detach(&request);
req_log(ISC_LOG_DEBUG(3), "dns_request_create: failed %s", req_log(ISC_LOG_DEBUG(3), "dns_request_create: failed %s",
isc_result_totext(result)); isc_result_totext(result));
return (result); return (result);
@ -887,7 +869,7 @@ dns_request_usedtcp(dns_request_t *request) {
void void
dns_request_destroy(dns_request_t **requestp) { dns_request_destroy(dns_request_t **requestp) {
dns_request_t *request; dns_request_t *request = NULL;
REQUIRE(requestp != NULL && VALID_REQUEST(*requestp)); REQUIRE(requestp != NULL && VALID_REQUEST(*requestp));
@ -909,8 +891,16 @@ dns_request_destroy(dns_request_t **requestp) {
INSIST(request->dispentry == NULL); INSIST(request->dispentry == NULL);
INSIST(request->dispatch == NULL); INSIST(request->dispatch == NULL);
/*
* if we've called the completion handler, there's
* another ref to detach
*/
if (request->complete) {
dns_request_unref(request);
}
/* final detach to shut down request */ /* final detach to shut down request */
req_detach(&request); dns_request_detach(&request);
} }
static void static void
@ -944,7 +934,7 @@ req_connected(isc_result_t eresult, isc_region_t *region, void *arg) {
UNLOCK(&request->requestmgr->locks[request->hash]); UNLOCK(&request->requestmgr->locks[request->hash]);
/* attached in dns_request_create/_createraw() */ /* attached in dns_request_create/_createraw() */
req_detach(&(dns_request_t *){ request }); dns_request_unref(request);
} }
static void static void
@ -975,7 +965,7 @@ req_senddone(isc_result_t eresult, isc_region_t *region, void *arg) {
UNLOCK(&request->requestmgr->locks[request->hash]); UNLOCK(&request->requestmgr->locks[request->hash]);
/* attached in req_send() */ /* attached in req_send() */
req_detach(&request); dns_request_detach(&request);
} }
static void static void
@ -1041,53 +1031,26 @@ done:
static void static void
req_sendevent(dns_request_t *request, isc_result_t result) { req_sendevent(dns_request_t *request, isc_result_t result) {
isc_task_t *task = NULL;
REQUIRE(VALID_REQUEST(request)); REQUIRE(VALID_REQUEST(request));
if (request->event == NULL) { if (request->complete) {
return; return;
} }
req_log(ISC_LOG_DEBUG(3), "req_sendevent: request %p", request); req_log(ISC_LOG_DEBUG(3), "req_sendevent: request %p", request);
/* dns_request_ref(request);
* Lock held by caller.
*/
task = request->event->ev_sender;
request->event->ev_sender = request;
request->event->result = result;
isc_task_sendanddetach(&task, (isc_event_t **)&request->event); request->result = result;
} request->complete = true;
static void isc_async_run(request->loop, request->cb, request);
req_attach(dns_request_t *source, dns_request_t **targetp) {
REQUIRE(VALID_REQUEST(source));
REQUIRE(targetp != NULL && *targetp == NULL);
isc_refcount_increment(&source->references);
*targetp = source;
}
static void
req_detach(dns_request_t **requestp) {
dns_request_t *request = NULL;
REQUIRE(requestp != NULL && VALID_REQUEST(*requestp));
request = *requestp;
*requestp = NULL;
if (isc_refcount_decrement(&request->references) == 1) {
req_destroy(request);
}
} }
static void static void
req_destroy(dns_request_t *request) { req_destroy(dns_request_t *request) {
REQUIRE(VALID_REQUEST(request)); REQUIRE(VALID_REQUEST(request));
REQUIRE(!ISC_LINK_LINKED(request, link));
req_log(ISC_LOG_DEBUG(3), "req_destroy: request %p", request); req_log(ISC_LOG_DEBUG(3), "req_destroy: request %p", request);
@ -1100,9 +1063,6 @@ req_destroy(dns_request_t *request) {
if (request->answer != NULL) { if (request->answer != NULL) {
isc_buffer_free(&request->answer); isc_buffer_free(&request->answer);
} }
if (request->event != NULL) {
isc_event_free((isc_event_t **)&request->event);
}
if (request->dispentry != NULL) { if (request->dispentry != NULL) {
dns_dispatch_done(&request->dispentry); dns_dispatch_done(&request->dispentry);
} }
@ -1121,6 +1081,22 @@ req_destroy(dns_request_t *request) {
isc_mem_putanddetach(&request->mctx, request, sizeof(*request)); isc_mem_putanddetach(&request->mctx, request, sizeof(*request));
} }
void *
dns_request_getarg(dns_request_t *request) {
REQUIRE(VALID_REQUEST(request));
return (request->arg);
}
isc_result_t
dns_request_getresult(dns_request_t *request) {
REQUIRE(VALID_REQUEST(request));
return (request->result);
}
ISC_REFCOUNT_IMPL(dns_request, req_destroy);
static void static void
req_log(int level, const char *fmt, ...) { req_log(int level, const char *fmt, ...) {
va_list ap; va_list ap;

6
lib/dns/resolver.c
View File

@ -10944,12 +10944,6 @@ dns_resolver_dispatchv6(dns_resolver_t *resolver) {
return (dns_dispatchset_get(resolver->dispatches6)); return (dns_dispatchset_get(resolver->dispatches6));
} }
isc_taskmgr_t *
dns_resolver_taskmgr(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
return (resolver->taskmgr);
}
uint32_t uint32_t
dns_resolver_getlamettl(dns_resolver_t *resolver) { dns_resolver_getlamettl(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver)); REQUIRE(VALID_RESOLVER(resolver));

5
lib/dns/view.c
View File

@ -676,9 +676,8 @@ dns_view_createresolver(dns_view_t *view, isc_loopmgr_t *loopmgr,
} }
result = dns_requestmgr_create( result = dns_requestmgr_create(
view->mctx, dns_resolver_taskmgr(view->resolver), view->mctx, dns_resolver_dispatchmgr(view->resolver),
dns_resolver_dispatchmgr(view->resolver), dispatchv4, dispatchv4, dispatchv6, &view->requestmgr);
dispatchv6, &view->requestmgr);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
goto cleanup_adb; goto cleanup_adb;
} }

182
lib/dns/zone.c
View File

@ -877,9 +877,9 @@ zone_viewname_tostr(dns_zone_t *zone, char *buf, size_t length);
static isc_result_t static isc_result_t
zone_send_secureserial(dns_zone_t *zone, uint32_t serial); zone_send_secureserial(dns_zone_t *zone, uint32_t serial);
static void static void
refresh_callback(isc_task_t *, isc_event_t *); refresh_callback(void *arg);
static void static void
stub_callback(isc_task_t *, isc_event_t *); stub_callback(void *arg);
static void static void
queue_soa_query(dns_zone_t *zone); queue_soa_query(dns_zone_t *zone);
static void static void
@ -895,7 +895,7 @@ checkds_send(dns_zone_t *zone);
static void static void
checkds_createmessage(dns_zone_t *zone, dns_message_t **messagep); checkds_createmessage(dns_zone_t *zone, dns_message_t **messagep);
static void static void
checkds_done(isc_task_t *task, isc_event_t *event); checkds_done(void *arg);
static void static void
checkds_send_toaddr(void *arg); checkds_send_toaddr(void *arg);
static void static void
@ -908,7 +908,7 @@ static isc_result_t
notify_createmessage(dns_zone_t *zone, unsigned int flags, notify_createmessage(dns_zone_t *zone, unsigned int flags,
dns_message_t **messagep); dns_message_t **messagep);
static void static void
notify_done(isc_task_t *task, isc_event_t *event); notify_done(void *arg);
static void static void
notify_send_toaddr(void *arg); notify_send_toaddr(void *arg);
static isc_result_t static isc_result_t
@ -933,7 +933,7 @@ zone_get_from_db(dns_zone_t *zone, dns_db_t *db, unsigned int *nscount,
static void static void
zone_freedbargs(dns_zone_t *zone); zone_freedbargs(dns_zone_t *zone);
static void static void
forward_callback(isc_task_t *task, isc_event_t *event); forward_callback(void *arg);
static void static void
zone_saveunique(dns_zone_t *zone, const char *path, const char *templat); zone_saveunique(dns_zone_t *zone, const char *path, const char *templat);
static void static void
@ -12297,7 +12297,7 @@ notify_send_toaddr(void *arg) {
result = dns_request_create( result = dns_request_create(
notify->zone->view->requestmgr, message, &src, &notify->dst, notify->zone->view->requestmgr, message, &src, &notify->dst,
NULL, NULL, options, key, timeout * 3, timeout, 2, NULL, NULL, options, key, timeout * 3, timeout, 2,
notify->zone->task, notify_done, notify, &notify->request); notify->zone->loop, notify_done, notify, &notify->request);
if (result == ISC_R_SUCCESS) { if (result == ISC_R_SUCCESS) {
if (isc_sockaddr_pf(&notify->dst) == AF_INET) { if (isc_sockaddr_pf(&notify->dst) == AF_INET) {
inc_stats(notify->zone, inc_stats(notify->zone,
@ -12770,9 +12770,11 @@ stub_finish_zone_update(dns_stub_t *stub, isc_time_t now) {
* was missing in a previous answer for a NS query. * was missing in a previous answer for a NS query.
*/ */
static void static void
stub_glue_response_cb(isc_task_t *task, isc_event_t *event) { stub_glue_response(void *arg) {
dns_requestevent_t *revent = (dns_requestevent_t *)event; dns_request_t *request = (dns_request_t *)arg;
dns_stub_t *stub = NULL; struct stub_glue_request *sgr = dns_request_getarg(request);
struct stub_cb_args *cb_args = sgr->args;
dns_stub_t *stub = cb_args->stub;
dns_message_t *msg = NULL; dns_message_t *msg = NULL;
dns_zone_t *zone = NULL; dns_zone_t *zone = NULL;
char primary[ISC_SOCKADDR_FORMATSIZE]; char primary[ISC_SOCKADDR_FORMATSIZE];
@ -12781,16 +12783,9 @@ stub_glue_response_cb(isc_task_t *task, isc_event_t *event) {
isc_result_t result; isc_result_t result;
isc_sockaddr_t curraddr; isc_sockaddr_t curraddr;
isc_time_t now; isc_time_t now;
struct stub_glue_request *request;
struct stub_cb_args *cb_args;
dns_rdataset_t *addr_rdataset = NULL; dns_rdataset_t *addr_rdataset = NULL;
dns_dbnode_t *node = NULL; dns_dbnode_t *node = NULL;
UNUSED(task);
request = revent->ev_arg;
cb_args = request->args;
stub = cb_args->stub;
INSIST(DNS_STUB_VALID(stub)); INSIST(DNS_STUB_VALID(stub));
zone = stub->zone; zone = stub->zone;
@ -12810,19 +12805,19 @@ stub_glue_response_cb(isc_task_t *task, isc_event_t *event) {
isc_sockaddr_format(&curraddr, primary, sizeof(primary)); isc_sockaddr_format(&curraddr, primary, sizeof(primary));
isc_sockaddr_format(&zone->sourceaddr, source, sizeof(source)); isc_sockaddr_format(&zone->sourceaddr, source, sizeof(source));
if (revent->result != ISC_R_SUCCESS) { if (dns_request_getresult(request) != ISC_R_SUCCESS) {
dns_zonemgr_unreachableadd(zone->zmgr, &curraddr, dns_zonemgr_unreachableadd(zone->zmgr, &curraddr,
&zone->sourceaddr, &now); &zone->sourceaddr, &now);
dns_zone_log(zone, ISC_LOG_INFO, dns_zone_log(zone, ISC_LOG_INFO,
"could not refresh stub from primary %s" "could not refresh stub from primary %s"
" (source %s): %s", " (source %s): %s",
primary, source, primary, source,
isc_result_totext(revent->result)); isc_result_totext(dns_request_getresult(request)));
goto cleanup; goto cleanup;
} }
dns_message_create(zone->mctx, DNS_MESSAGE_INTENTPARSE, &msg); dns_message_create(zone->mctx, DNS_MESSAGE_INTENTPARSE, &msg);
result = dns_request_getresponse(revent->request, msg, 0); result = dns_request_getresponse(request, msg, 0);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_INFO, dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: unable to parse response (%s)", "refreshing stub: unable to parse response (%s)",
@ -12868,7 +12863,7 @@ stub_glue_response_cb(isc_task_t *task, isc_event_t *event) {
* We need complete messages. * We need complete messages.
*/ */
if ((msg->flags & DNS_MESSAGEFLAG_TC) != 0) { if ((msg->flags & DNS_MESSAGEFLAG_TC) != 0) {
if (dns_request_usedtcp(revent->request)) { if (dns_request_usedtcp(request)) {
dns_zone_log(zone, ISC_LOG_INFO, dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: truncated TCP " "refreshing stub: truncated TCP "
"response from primary %s (source %s)", "response from primary %s (source %s)",
@ -12894,8 +12889,8 @@ stub_glue_response_cb(isc_task_t *task, isc_event_t *event) {
*/ */
cnamecnt = message_count(msg, DNS_SECTION_ANSWER, dns_rdatatype_cname); cnamecnt = message_count(msg, DNS_SECTION_ANSWER, dns_rdatatype_cname);
addr_count = message_count(msg, DNS_SECTION_ANSWER, addr_count = message_count(msg, DNS_SECTION_ANSWER,
request->ipv4 ? dns_rdatatype_a sgr->ipv4 ? dns_rdatatype_a
: dns_rdatatype_aaaa); : dns_rdatatype_aaaa);
if (cnamecnt != 0) { if (cnamecnt != 0) {
dns_zone_log(zone, ISC_LOG_INFO, dns_zone_log(zone, ISC_LOG_INFO,
@ -12909,32 +12904,31 @@ stub_glue_response_cb(isc_task_t *task, isc_event_t *event) {
dns_zone_log(zone, ISC_LOG_INFO, dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: no %s records in response " "refreshing stub: no %s records in response "
"from primary %s (source %s)", "from primary %s (source %s)",
request->ipv4 ? "A" : "AAAA", primary, source); sgr->ipv4 ? "A" : "AAAA", primary, source);
goto cleanup; goto cleanup;
} }
/* /*
* Extract A or AAAA RRset from message. * Extract A or AAAA RRset from message.
*/ */
result = dns_message_findname(msg, DNS_SECTION_ANSWER, &request->name, result = dns_message_findname(msg, DNS_SECTION_ANSWER, &sgr->name,
request->ipv4 ? dns_rdatatype_a sgr->ipv4 ? dns_rdatatype_a
: dns_rdatatype_aaaa, : dns_rdatatype_aaaa,
dns_rdatatype_none, NULL, &addr_rdataset); dns_rdatatype_none, NULL, &addr_rdataset);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
if (result != DNS_R_NXDOMAIN && result != DNS_R_NXRRSET) { if (result != DNS_R_NXDOMAIN && result != DNS_R_NXRRSET) {
char namebuf[DNS_NAME_FORMATSIZE]; char namebuf[DNS_NAME_FORMATSIZE];
dns_name_format(&request->name, namebuf, dns_name_format(&sgr->name, namebuf, sizeof(namebuf));
sizeof(namebuf));
dns_zone_log( dns_zone_log(
zone, ISC_LOG_INFO, zone, ISC_LOG_INFO,
"refreshing stub: dns_message_findname(%s/%s) " "refreshing stub: dns_message_findname(%s/%s) "
"failed (%s)", "failed (%s)",
namebuf, request->ipv4 ? "A" : "AAAA", namebuf, sgr->ipv4 ? "A" : "AAAA",
isc_result_totext(result)); isc_result_totext(result));
} }
goto cleanup; goto cleanup;
} }
result = dns_db_findnode(stub->db, &request->name, true, &node); result = dns_db_findnode(stub->db, &sgr->name, true, &node);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_INFO, dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: " "refreshing stub: "
@ -12957,10 +12951,8 @@ cleanup:
if (msg != NULL) { if (msg != NULL) {
dns_message_detach(&msg); dns_message_detach(&msg);
} }
isc_event_free(&event); dns_name_free(&sgr->name, zone->mctx);
dns_name_free(&request->name, zone->mctx); dns_request_destroy(&request);
dns_request_destroy(&request->request);
isc_mem_put(zone->mctx, request, sizeof(*request));
/* If last request, release all related resources */ /* If last request, release all related resources */
if (atomic_fetch_sub_release(&stub->pending_requests, 1) == 1) { if (atomic_fetch_sub_release(&stub->pending_requests, 1) == 1) {
@ -13017,8 +13009,8 @@ stub_request_nameserver_address(struct stub_cb_args *args, bool ipv4,
result = dns_request_create( result = dns_request_create(
zone->view->requestmgr, message, &zone->sourceaddr, &curraddr, zone->view->requestmgr, message, &zone->sourceaddr, &curraddr,
NULL, NULL, DNS_REQUESTOPT_TCP, args->tsig_key, NULL, NULL, DNS_REQUESTOPT_TCP, args->tsig_key,
args->timeout * 3, args->timeout, 2, zone->task, args->timeout * 3, args->timeout, 2, zone->loop,
stub_glue_response_cb, request, &request->request); stub_glue_response, request, &request->request);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
uint_fast32_t pr; uint_fast32_t pr;
@ -13196,9 +13188,10 @@ done:
} }
static void static void
stub_callback(isc_task_t *task, isc_event_t *event) { stub_callback(void *arg) {
dns_requestevent_t *revent = (dns_requestevent_t *)event; dns_request_t *request = (dns_request_t *)arg;
dns_stub_t *stub = NULL; struct stub_cb_args *cb_args = dns_request_getarg(request);
dns_stub_t *stub = cb_args->stub;
dns_message_t *msg = NULL; dns_message_t *msg = NULL;
dns_zone_t *zone = NULL; dns_zone_t *zone = NULL;
char primary[ISC_SOCKADDR_FORMATSIZE]; char primary[ISC_SOCKADDR_FORMATSIZE];
@ -13208,14 +13201,9 @@ stub_callback(isc_task_t *task, isc_event_t *event) {
isc_sockaddr_t curraddr; isc_sockaddr_t curraddr;
isc_time_t now; isc_time_t now;
bool exiting = false; bool exiting = false;
struct stub_cb_args *cb_args;
cb_args = revent->ev_arg;
stub = cb_args->stub;
INSIST(DNS_STUB_VALID(stub)); INSIST(DNS_STUB_VALID(stub));
UNUSED(task);
zone = stub->zone; zone = stub->zone;
ENTER; ENTER;
@ -13232,7 +13220,8 @@ stub_callback(isc_task_t *task, isc_event_t *event) {
isc_sockaddr_format(&curraddr, primary, sizeof(primary)); isc_sockaddr_format(&curraddr, primary, sizeof(primary));
isc_sockaddr_format(&zone->sourceaddr, source, sizeof(source)); isc_sockaddr_format(&zone->sourceaddr, source, sizeof(source));
switch (revent->result) { result = dns_request_getresult(request);
switch (result) {
case ISC_R_SUCCESS: case ISC_R_SUCCESS:
break; break;
case ISC_R_SHUTTINGDOWN: case ISC_R_SHUTTINGDOWN:
@ -13253,14 +13242,13 @@ stub_callback(isc_task_t *task, isc_event_t *event) {
dns_zone_log(zone, ISC_LOG_INFO, dns_zone_log(zone, ISC_LOG_INFO,
"could not refresh stub from primary " "could not refresh stub from primary "
"%s (source %s): %s", "%s (source %s): %s",
primary, source, primary, source, isc_result_totext(result));
isc_result_totext(revent->result));
goto next_primary; goto next_primary;
} }
dns_message_create(zone->mctx, DNS_MESSAGE_INTENTPARSE, &msg); dns_message_create(zone->mctx, DNS_MESSAGE_INTENTPARSE, &msg);
result = dns_request_getresponse(revent->request, msg, 0); result = dns_request_getresponse(request, msg, 0);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
goto next_primary; goto next_primary;
} }
@ -13316,7 +13304,7 @@ stub_callback(isc_task_t *task, isc_event_t *event) {
* We need complete messages. * We need complete messages.
*/ */
if ((msg->flags & DNS_MESSAGEFLAG_TC) != 0) { if ((msg->flags & DNS_MESSAGEFLAG_TC) != 0) {
if (dns_request_usedtcp(revent->request)) { if (dns_request_usedtcp(request)) {
dns_zone_log(zone, ISC_LOG_INFO, dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: truncated TCP " "refreshing stub: truncated TCP "
"response from primary %s (source %s)", "response from primary %s (source %s)",
@ -13377,7 +13365,6 @@ stub_callback(isc_task_t *task, isc_event_t *event) {
} }
dns_message_detach(&msg); dns_message_detach(&msg);
isc_event_free(&event);
dns_request_destroy(&zone->request); dns_request_destroy(&zone->request);
/* /*
@ -13408,7 +13395,6 @@ next_primary:
if (msg != NULL) { if (msg != NULL) {
dns_message_detach(&msg); dns_message_detach(&msg);
} }
isc_event_free(&event);
dns_request_destroy(&zone->request); dns_request_destroy(&zone->request);
/* /*
* Skip to next failed / untried primary. * Skip to next failed / untried primary.
@ -13428,11 +13414,10 @@ same_primary:
if (msg != NULL) { if (msg != NULL) {
dns_message_detach(&msg); dns_message_detach(&msg);
} }
isc_event_free(&event);
dns_request_destroy(&zone->request); dns_request_destroy(&zone->request);
ns_query(zone, NULL, stub); ns_query(zone, NULL, stub);
UNLOCK_ZONE(zone); UNLOCK_ZONE(zone);
goto done; return;
free_stub: free_stub:
UNLOCK_ZONE(zone); UNLOCK_ZONE(zone);
@ -13441,10 +13426,6 @@ free_stub:
INSIST(stub->db == NULL); INSIST(stub->db == NULL);
INSIST(stub->version == NULL); INSIST(stub->version == NULL);
isc_mem_put(stub->mctx, stub, sizeof(*stub)); isc_mem_put(stub->mctx, stub, sizeof(*stub));
done:
INSIST(event == NULL);
return;
} }
/* /*
@ -13541,9 +13522,9 @@ setmodtime(dns_zone_t *zone, isc_time_t *expiretime) {
* An SOA query has finished (successfully or not). * An SOA query has finished (successfully or not).
*/ */
static void static void
refresh_callback(isc_task_t *task, isc_event_t *event) { refresh_callback(void *arg) {
dns_requestevent_t *revent = (dns_requestevent_t *)event; dns_request_t *request = (dns_request_t *)arg;
dns_zone_t *zone; dns_zone_t *zone = dns_request_getarg(request);
dns_message_t *msg = NULL; dns_message_t *msg = NULL;
uint32_t soacnt, cnamecnt, soacount, nscount; uint32_t soacnt, cnamecnt, soacount, nscount;
isc_time_t now; isc_time_t now;
@ -13557,11 +13538,8 @@ refresh_callback(isc_task_t *task, isc_event_t *event) {
uint32_t serial, oldserial = 0; uint32_t serial, oldserial = 0;
bool do_queue_xfrin = false; bool do_queue_xfrin = false;
zone = revent->ev_arg;
INSIST(DNS_ZONE_VALID(zone)); INSIST(DNS_ZONE_VALID(zone));
UNUSED(task);
ENTER; ENTER;
TIME_NOW(&now); TIME_NOW(&now);
@ -13579,7 +13557,7 @@ refresh_callback(isc_task_t *task, isc_event_t *event) {
isc_sockaddr_format(&curraddr, primary, sizeof(primary)); isc_sockaddr_format(&curraddr, primary, sizeof(primary));
isc_sockaddr_format(&zone->sourceaddr, source, sizeof(source)); isc_sockaddr_format(&zone->sourceaddr, source, sizeof(source));
switch (revent->result) { switch (dns_request_getresult(request)) {
case ISC_R_SUCCESS: case ISC_R_SUCCESS:
break; break;
case ISC_R_SHUTTINGDOWN: case ISC_R_SHUTTINGDOWN:
@ -13592,7 +13570,7 @@ refresh_callback(isc_task_t *task, isc_event_t *event) {
"primary %s (source %s)", "primary %s (source %s)",
primary, source); primary, source);
goto same_primary; goto same_primary;
} else if (!dns_request_usedtcp(revent->request)) { } else if (!dns_request_usedtcp(request)) {
dns_zone_log(zone, ISC_LOG_INFO, dns_zone_log(zone, ISC_LOG_INFO,
"refresh: retry limit for " "refresh: retry limit for "
"primary %s exceeded (source %s)", "primary %s exceeded (source %s)",
@ -13626,12 +13604,12 @@ refresh_callback(isc_task_t *task, isc_event_t *event) {
"refresh: failure trying primary " "refresh: failure trying primary "
"%s (source %s): %s", "%s (source %s): %s",
primary, source, primary, source,
isc_result_totext(revent->result)); isc_result_totext(dns_request_getresult(request)));
goto next_primary; goto next_primary;
} }
dns_message_create(zone->mctx, DNS_MESSAGE_INTENTPARSE, &msg); dns_message_create(zone->mctx, DNS_MESSAGE_INTENTPARSE, &msg);
result = dns_request_getresponse(revent->request, msg, 0); result = dns_request_getresponse(request, msg, 0);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_INFO, dns_zone_log(zone, ISC_LOG_INFO,
"refresh: failure trying primary " "refresh: failure trying primary "
@ -13724,7 +13702,7 @@ refresh_callback(isc_task_t *task, isc_event_t *event) {
goto tcp_transfer; goto tcp_transfer;
} else { } else {
INSIST(zone->type == dns_zone_stub); INSIST(zone->type == dns_zone_stub);
if (dns_request_usedtcp(revent->request)) { if (dns_request_usedtcp(request)) {
dns_zone_log(zone, ISC_LOG_INFO, dns_zone_log(zone, ISC_LOG_INFO,
"refresh: truncated TCP response " "refresh: truncated TCP response "
"from primary %s (source %s)", "from primary %s (source %s)",
@ -13856,7 +13834,6 @@ refresh_callback(isc_task_t *task, isc_event_t *event) {
goto next_primary; goto next_primary;
} }
tcp_transfer: tcp_transfer:
isc_event_free(&event);
dns_request_destroy(&zone->request); dns_request_destroy(&zone->request);
if (zone->type == dns_zone_secondary || if (zone->type == dns_zone_secondary ||
zone->type == dns_zone_mirror || zone->type == dns_zone_mirror ||
@ -13915,7 +13892,6 @@ next_primary:
if (msg != NULL) { if (msg != NULL) {
dns_message_detach(&msg); dns_message_detach(&msg);
} }
isc_event_free(&event);
dns_request_destroy(&zone->request); dns_request_destroy(&zone->request);
/* /*
* Skip to next failed / untried primary. * Skip to next failed / untried primary.
@ -13936,7 +13912,6 @@ next_primary:
goto detach; goto detach;
exiting: exiting:
isc_event_free(&event);
dns_request_destroy(&zone->request); dns_request_destroy(&zone->request);
goto detach; goto detach;
@ -13944,7 +13919,6 @@ same_primary:
if (msg != NULL) { if (msg != NULL) {
dns_message_detach(&msg); dns_message_detach(&msg);
} }
isc_event_free(&event);
dns_request_destroy(&zone->request); dns_request_destroy(&zone->request);
queue_soa_query(zone); queue_soa_query(zone);
@ -14169,7 +14143,7 @@ again:
} }
result = dns_request_create( result = dns_request_create(
zone->view->requestmgr, message, &zone->sourceaddr, &curraddr, zone->view->requestmgr, message, &zone->sourceaddr, &curraddr,
NULL, NULL, options, key, timeout * 3, timeout, 2, zone->task, NULL, NULL, options, key, timeout * 3, timeout, 2, zone->loop,
refresh_callback, zone, &zone->request); refresh_callback, zone, &zone->request);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
zone_idetach(&(dns_zone_t *){ zone }); zone_idetach(&(dns_zone_t *){ zone });
@ -14440,7 +14414,7 @@ ns_query(dns_zone_t *zone, dns_rdataset_t *soardataset, dns_stub_t *stub) {
result = dns_request_create( result = dns_request_create(
zone->view->requestmgr, message, &zone->sourceaddr, &curraddr, zone->view->requestmgr, message, &zone->sourceaddr, &curraddr,
NULL, NULL, DNS_REQUESTOPT_TCP, key, timeout * 3, timeout, 2, NULL, NULL, DNS_REQUESTOPT_TCP, key, timeout * 3, timeout, 2,
zone->task, stub_callback, cb_args, &zone->request); zone->loop, stub_callback, cb_args, &zone->request);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
zone_debuglog(zone, __func__, 1, zone_debuglog(zone, __func__, 1,
"dns_request_create() failed: %s", "dns_request_create() failed: %s",
@ -15757,32 +15731,28 @@ dns_zone_getidleout(dns_zone_t *zone) {
} }
static void static void
notify_done(isc_task_t *task, isc_event_t *event) { notify_done(void *arg) {
dns_requestevent_t *revent = (dns_requestevent_t *)event; dns_request_t *request = (dns_request_t *)arg;
dns_notify_t *notify; dns_notify_t *notify = dns_request_getarg(request);
isc_result_t result; isc_result_t result;
dns_message_t *message = NULL; dns_message_t *message = NULL;
isc_buffer_t buf; isc_buffer_t buf;
char rcode[128]; char rcode[128];
char addrbuf[ISC_SOCKADDR_FORMATSIZE]; char addrbuf[ISC_SOCKADDR_FORMATSIZE];
UNUSED(task);
notify = event->ev_arg;
REQUIRE(DNS_NOTIFY_VALID(notify)); REQUIRE(DNS_NOTIFY_VALID(notify));
INSIST(task == notify->zone->task);
isc_buffer_init(&buf, rcode, sizeof(rcode)); isc_buffer_init(&buf, rcode, sizeof(rcode));
isc_sockaddr_format(&notify->dst, addrbuf, sizeof(addrbuf)); isc_sockaddr_format(&notify->dst, addrbuf, sizeof(addrbuf));
dns_message_create(notify->zone->mctx, DNS_MESSAGE_INTENTPARSE, dns_message_create(notify->zone->mctx, DNS_MESSAGE_INTENTPARSE,
&message); &message);
if (revent->result != ISC_R_SUCCESS) { result = dns_request_getresult(request);
result = revent->result; if (result != ISC_R_SUCCESS) {
goto fail; goto fail;
} }
result = dns_request_getresponse(revent->request, message, result = dns_request_getresponse(request, message,
DNS_MESSAGEPARSE_PRESERVEORDER); DNS_MESSAGEPARSE_PRESERVEORDER);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
goto fail; goto fail;
@ -15806,7 +15776,6 @@ fail:
} }
done: done:
notify_destroy(notify, false); notify_destroy(notify, false);
isc_event_free(&event);
dns_message_detach(&message); dns_message_detach(&message);
} }
@ -17708,7 +17677,7 @@ sendtoprimary(dns_forward_t *forward) {
result = dns_request_createraw( result = dns_request_createraw(
forward->zone->view->requestmgr, forward->msgbuf, &src, forward->zone->view->requestmgr, forward->msgbuf, &src,
&forward->addr, forward->transport, zone->zmgr->tlsctx_cache, &forward->addr, forward->transport, zone->zmgr->tlsctx_cache,
forward->options, 15 /* XXX */, 0, 0, forward->zone->task, forward->options, 15 /* XXX */, 0, 0, forward->zone->loop,
forward_callback, forward, &forward->request); forward_callback, forward, &forward->request);
if (result == ISC_R_SUCCESS) { if (result == ISC_R_SUCCESS) {
if (!ISC_LINK_LINKED(forward, link)) { if (!ISC_LINK_LINKED(forward, link)) {
@ -17730,17 +17699,14 @@ unlock:
} }
static void static void
forward_callback(isc_task_t *task, isc_event_t *event) { forward_callback(void *arg) {
dns_requestevent_t *revent = (dns_requestevent_t *)event; dns_request_t *request = (dns_request_t *)arg;
dns_forward_t *forward = dns_request_getarg(request);
dns_message_t *msg = NULL; dns_message_t *msg = NULL;
char primary[ISC_SOCKADDR_FORMATSIZE]; char primary[ISC_SOCKADDR_FORMATSIZE];
isc_result_t result; isc_result_t result;
dns_forward_t *forward;
dns_zone_t *zone; dns_zone_t *zone;
UNUSED(task);
forward = revent->ev_arg;
INSIST(DNS_FORWARD_VALID(forward)); INSIST(DNS_FORWARD_VALID(forward));
zone = forward->zone; zone = forward->zone;
INSIST(DNS_ZONE_VALID(zone)); INSIST(DNS_ZONE_VALID(zone));
@ -17749,16 +17715,17 @@ forward_callback(isc_task_t *task, isc_event_t *event) {
isc_sockaddr_format(&forward->addr, primary, sizeof(primary)); isc_sockaddr_format(&forward->addr, primary, sizeof(primary));
if (revent->result != ISC_R_SUCCESS) { result = dns_request_getresult(request);
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_INFO, dns_zone_log(zone, ISC_LOG_INFO,
"could not forward dynamic update to %s: %s", "could not forward dynamic update to %s: %s",
primary, isc_result_totext(revent->result)); primary, isc_result_totext(result));
goto next_primary; goto next_primary;
} }
dns_message_create(zone->mctx, DNS_MESSAGE_INTENTPARSE, &msg); dns_message_create(zone->mctx, DNS_MESSAGE_INTENTPARSE, &msg);
result = dns_request_getresponse(revent->request, msg, result = dns_request_getresponse(request, msg,
DNS_MESSAGEPARSE_PRESERVEORDER | DNS_MESSAGEPARSE_PRESERVEORDER |
DNS_MESSAGEPARSE_CLONEBUFFER); DNS_MESSAGEPARSE_CLONEBUFFER);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
@ -17833,14 +17800,12 @@ forward_callback(isc_task_t *task, isc_event_t *event) {
msg = NULL; msg = NULL;
dns_request_destroy(&forward->request); dns_request_destroy(&forward->request);
forward_destroy(forward); forward_destroy(forward);
isc_event_free(&event);
return; return;
next_primary: next_primary:
if (msg != NULL) { if (msg != NULL) {
dns_message_detach(&msg); dns_message_detach(&msg);
} }
isc_event_free(&event);
forward->which++; forward->which++;
dns_request_destroy(&forward->request); dns_request_destroy(&forward->request);
result = sendtoprimary(forward); result = sendtoprimary(forward);
@ -18089,9 +18054,7 @@ dns_zonemgr_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
ISC_MEM_ZERO); ISC_MEM_ZERO);
for (size_t i = 0; i < zmgr->workers; i++) { for (size_t i = 0; i < zmgr->workers; i++) {
result = isc_task_create(zmgr->taskmgr, &zmgr->zonetasks[i], i); result = isc_task_create(zmgr->taskmgr, &zmgr->zonetasks[i], i);
INSIST(result == ISC_R_SUCCESS);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
INSIST(result == ISC_R_SUCCESS);
goto free_zonetasks; goto free_zonetasks;
} }
isc_task_setname(zmgr->zonetasks[i], "zonemgr-zonetasks", NULL); isc_task_setname(zmgr->zonetasks[i], "zonemgr-zonetasks", NULL);
@ -19820,19 +19783,19 @@ validate_ds(dns_zone_t *zone, dns_message_t *message) {
} }
static void static void
checkds_done(isc_task_t *task, isc_event_t *event) { checkds_done(void *arg) {
dns_request_t *request = (dns_request_t *)arg;
dns_checkds_t *checkds = dns_request_getarg(request);
char addrbuf[ISC_SOCKADDR_FORMATSIZE]; char addrbuf[ISC_SOCKADDR_FORMATSIZE];
char rcode[128]; char rcode[128];
dns_checkds_t *checkds; dns_zone_t *zone = NULL;
dns_zone_t *zone;
dns_db_t *db = NULL; dns_db_t *db = NULL;
dns_dbversion_t *version = NULL; dns_dbversion_t *version = NULL;
dns_dnsseckey_t *key; dns_dnsseckey_t *key = NULL;
dns_dnsseckeylist_t keys; dns_dnsseckeylist_t keys;
dns_kasp_t *kasp = NULL; dns_kasp_t *kasp = NULL;
dns_message_t *message = NULL; dns_message_t *message = NULL;
dns_rdataset_t *ds_rrset = NULL; dns_rdataset_t *ds_rrset = NULL;
dns_requestevent_t *revent = (dns_requestevent_t *)event;
isc_buffer_t buf; isc_buffer_t buf;
isc_result_t result; isc_result_t result;
isc_stdtime_t now; isc_stdtime_t now;
@ -19840,13 +19803,9 @@ checkds_done(isc_task_t *task, isc_event_t *event) {
bool rekey = false; bool rekey = false;
bool empty = false; bool empty = false;
UNUSED(task);
checkds = event->ev_arg;
REQUIRE(DNS_CHECKDS_VALID(checkds)); REQUIRE(DNS_CHECKDS_VALID(checkds));
zone = checkds->zone; zone = checkds->zone;
INSIST(task == zone->task);
ISC_LIST_INIT(keys); ISC_LIST_INIT(keys);
@ -19862,8 +19821,8 @@ checkds_done(isc_task_t *task, isc_event_t *event) {
dns_message_create(zone->mctx, DNS_MESSAGE_INTENTPARSE, &message); dns_message_create(zone->mctx, DNS_MESSAGE_INTENTPARSE, &message);
INSIST(message != NULL); INSIST(message != NULL);
CHECK(revent->result); CHECK(dns_request_getresult(request));
CHECK(dns_request_getresponse(revent->request, message, CHECK(dns_request_getresponse(request, message,
DNS_MESSAGEPARSE_PRESERVEORDER)); DNS_MESSAGEPARSE_PRESERVEORDER));
CHECK(dns_rcode_totext(message->rcode, &buf)); CHECK(dns_rcode_totext(message->rcode, &buf));
@ -20055,7 +20014,6 @@ failure:
dns_dnsseckey_destroy(dns_zone_getmctx(zone), &key); dns_dnsseckey_destroy(dns_zone_getmctx(zone), &key);
} }
isc_event_free(&event);
checkds_destroy(checkds, false); checkds_destroy(checkds, false);
dns_message_detach(&message); dns_message_detach(&message);
} }
@ -20261,7 +20219,7 @@ checkds_send_toaddr(void *arg) {
result = dns_request_create( result = dns_request_create(
checkds->zone->view->requestmgr, message, &src, &checkds->dst, checkds->zone->view->requestmgr, message, &src, &checkds->dst,
NULL, NULL, options, key, timeout * 3, timeout, 2, NULL, NULL, options, key, timeout * 3, timeout, 2,
checkds->zone->task, checkds_done, checkds, &checkds->request); checkds->zone->loop, checkds_done, checkds, &checkds->request);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
dns_zone_log(checkds->zone, ISC_LOG_DEBUG(3), dns_zone_log(checkds->zone, ISC_LOG_DEBUG(3),
"checkds: dns_request_create() to %s failed: %s", "checkds: dns_request_create() to %s failed: %s",