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

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

@ -67,29 +67,24 @@ static isc_sockaddr_t dstaddr;
static int onfly;
static void
recvresponse(isc_task_t *task, isc_event_t *event) {
dns_requestevent_t *reqev = (dns_requestevent_t *)event;
recvresponse(void *arg) {
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;
isc_buffer_t outbuf;
char output[1024];
UNUSED(task);
REQUIRE(reqev != NULL);
if (reqev->result != ISC_R_SUCCESS) {
result = dns_request_getresult(request);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "I:request event result: %s\n",
isc_result_totext(reqev->result));
isc_result_totext(result));
exit(-1);
}
query = reqev->ev_arg;
dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &response);
result = dns_request_getresponse(reqev->request, response,
result = dns_request_getresponse(request, response,
DNS_MESSAGEPARSE_PRESERVEORDER);
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(&response);
dns_request_destroy(&reqev->request);
isc_event_free(&event);
dns_request_destroy(&request);
if (--onfly == 0) {
isc_task_detach(&task);
isc_loopmgr_shutdown(loopmgr);
}
return;
}
static isc_result_t
sendquery(isc_task_t *task) {
sendquery(void) {
dns_request_t *request = NULL;
dns_message_t *message = NULL;
dns_name_t *qname = NULL;
@ -168,10 +161,10 @@ sendquery(isc_task_t *task) {
ISC_LIST_APPEND(qname->list, qrdataset, link);
dns_message_addname(message, qname, DNS_SECTION_QUESTION);
result = dns_request_create(requestmgr, message,
have_src ? &srcaddr : NULL, &dstaddr, NULL,
NULL, DNS_REQUESTOPT_TCP, NULL, TIMEOUT, 0,
0, task, recvresponse, message, &request);
result = dns_request_create(
requestmgr, message, have_src ? &srcaddr : NULL, &dstaddr, NULL,
NULL, DNS_REQUESTOPT_TCP, NULL, TIMEOUT, 0, 0,
isc_loop_main(loopmgr), recvresponse, message, &request);
CHECK("dns_request_create", result);
return (ISC_R_SUCCESS);
@ -179,15 +172,15 @@ sendquery(isc_task_t *task) {
static void
sendqueries(void *arg) {
isc_task_t *task = (isc_task_t *)arg;
isc_result_t result;
UNUSED(arg);
do {
result = sendquery(task);
result = sendquery();
} while (result == ISC_R_SUCCESS);
if (onfly == 0) {
isc_task_detach(&task);
isc_loopmgr_shutdown(loopmgr);
}
return;
@ -202,7 +195,6 @@ main(int argc, char *argv[]) {
isc_logconfig_t *lcfg = NULL;
isc_nm_t *netmgr = NULL;
isc_taskmgr_t *taskmgr = NULL;
isc_task_t *task = NULL;
dns_dispatchmgr_t *dispatchmgr = NULL;
dns_dispatch_t *dispatchv4 = NULL;
dns_view_t *view = NULL;
@ -261,17 +253,16 @@ main(int argc, char *argv[]) {
RUNCHECK(dst_lib_init(mctx, NULL));
RUNCHECK(isc_task_create(taskmgr, &task, 0));
RUNCHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr));
RUNCHECK(dns_dispatch_createudp(
dispatchmgr, have_src ? &srcaddr : &bind_any, &dispatchv4));
RUNCHECK(dns_requestmgr_create(mctx, taskmgr, dispatchmgr, dispatchv4,
NULL, &requestmgr));
RUNCHECK(dns_requestmgr_create(mctx, dispatchmgr, dispatchv4, NULL,
&requestmgr));
RUNCHECK(dns_view_create(mctx, 0, "_test", &view));
isc_loopmgr_setup(loopmgr, sendqueries, task);
isc_loopmgr_setup(loopmgr, sendqueries, NULL);
isc_loopmgr_run(loopmgr);
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 void
recvquery(isc_task_t *task, isc_event_t *event) {
dns_requestevent_t *reqev = (dns_requestevent_t *)event;
recvquery(void *arg) {
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;
dns_message_t *query = NULL, *response = NULL;
char keyname[256];
isc_buffer_t keynamebuf;
int type;
UNUSED(task);
REQUIRE(reqev != NULL);
if (reqev->result != ISC_R_SUCCESS) {
result = dns_request_getresult(request);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "I:request event result: %s\n",
isc_result_totext(reqev->result));
isc_result_totext(result));
exit(-1);
}
query = reqev->ev_arg;
dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &response);
result = dns_request_getresponse(reqev->request, response,
result = dns_request_getresponse(request, response,
DNS_MESSAGEPARSE_PRESERVEORDER);
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(&response);
dns_request_destroy(&reqev->request);
isc_event_free(&event);
isc_task_detach(&task);
dns_request_destroy(&request);
isc_loopmgr_shutdown(loopmgr);
}
static void
sendquery(void *arg) {
isc_task_t *task = (isc_task_t *)arg;
struct in_addr inaddr;
isc_sockaddr_t address;
isc_region_t r;
@ -138,6 +131,8 @@ sendquery(void *arg) {
dns_request_t *request = NULL;
static char keystr[] = "0123456789ab";
UNUSED(arg);
result = ISC_R_FAILURE;
if (inet_pton(AF_INET, ip_address, &inaddr) != 1) {
CHECK("inet_pton", result);
@ -179,8 +174,8 @@ sendquery(void *arg) {
result = dns_request_create(requestmgr, query, NULL, &address, NULL,
NULL, DNS_REQUESTOPT_TCP, initialkey,
TIMEOUT, 0, 0, task, recvquery, query,
&request);
TIMEOUT, 0, 0, isc_loop_main(loopmgr),
recvquery, query, &request);
CHECK("dns_request_create", result);
}
@ -196,7 +191,6 @@ main(int argc, char *argv[]) {
dns_tkeyctx_t *tctx = NULL;
isc_log_t *log = NULL;
isc_logconfig_t *logconfig = NULL;
isc_task_t *task = NULL;
isc_result_t result;
int type;
@ -220,13 +214,12 @@ main(int argc, char *argv[]) {
RUNCHECK(dst_lib_init(mctx, NULL));
RUNCHECK(isc_task_create(taskmgr, &task, 0));
RUNCHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr));
isc_sockaddr_any(&bind_any);
RUNCHECK(dns_dispatch_createudp(dispatchmgr, &bind_any, &dispatchv4));
RUNCHECK(dns_requestmgr_create(mctx, taskmgr, dispatchmgr, dispatchv4,
NULL, &requestmgr));
RUNCHECK(dns_requestmgr_create(mctx, dispatchmgr, dispatchv4, NULL,
&requestmgr));
RUNCHECK(dns_tsigkeyring_create(mctx, &ring));
RUNCHECK(dns_tkeyctx_create(mctx, &tctx));
@ -243,7 +236,7 @@ main(int argc, char *argv[]) {
isc_nonce_buf(noncedata, sizeof(noncedata));
isc_buffer_add(&nonce, sizeof(noncedata));
isc_loopmgr_setup(loopmgr, sendquery, task);
isc_loopmgr_setup(loopmgr, sendquery, NULL);
isc_loopmgr_run(loopmgr);
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 void
recvquery(isc_task_t *task, isc_event_t *event) {
dns_requestevent_t *reqev = (dns_requestevent_t *)event;
recvquery(void *arg) {
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);
REQUIRE(reqev != NULL);
if (reqev->result != ISC_R_SUCCESS) {
result = dns_request_getresult(request);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "I:request event result: %s\n",
isc_result_totext(reqev->result));
isc_result_totext(result));
exit(-1);
}
query = reqev->ev_arg;
dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &response);
result = dns_request_getresponse(reqev->request, response,
result = dns_request_getresponse(request, response,
DNS_MESSAGEPARSE_PRESERVEORDER);
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(&response);
dns_request_destroy(&reqev->request);
isc_event_free(&event);
isc_task_detach(&task);
dns_request_destroy(&request);
isc_loopmgr_shutdown(loopmgr);
}
static void
sendquery(void *arg) {
isc_task_t *task = (isc_task_t *)arg;
struct in_addr inaddr;
isc_sockaddr_t address;
isc_result_t result;
dns_message_t *query = NULL;
dns_request_t *request = NULL;
UNUSED(arg);
result = ISC_R_FAILURE;
if (inet_pton(AF_INET, ip_address, &inaddr) != 1) {
CHECK("inet_pton", result);
@ -123,7 +118,8 @@ sendquery(void *arg) {
result = dns_request_create(requestmgr, query, NULL, &address, NULL,
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);
}
@ -140,7 +136,6 @@ main(int argc, char **argv) {
dst_key_t *dstkey = NULL;
isc_log_t *log = NULL;
isc_logconfig_t *logconfig = NULL;
isc_task_t *task = NULL;
isc_result_t result;
int type;
@ -162,12 +157,11 @@ main(int argc, char **argv) {
RUNCHECK(dst_lib_init(mctx, NULL));
RUNCHECK(isc_task_create(taskmgr, &task, 0));
RUNCHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr));
isc_sockaddr_any(&bind_any);
RUNCHECK(dns_dispatch_createudp(dispatchmgr, &bind_any, &dispatchv4));
RUNCHECK(dns_requestmgr_create(mctx, taskmgr, dispatchmgr, dispatchv4,
NULL, &requestmgr));
RUNCHECK(dns_requestmgr_create(mctx, dispatchmgr, dispatchv4, NULL,
&requestmgr));
RUNCHECK(dns_tsigkeyring_create(mctx, &ring));
RUNCHECK(dns_tkeyctx_create(mctx, &tctx));
@ -184,7 +178,7 @@ main(int argc, char **argv) {
dst_key_free(&dstkey);
CHECK("dns_tsigkey_createfromkey", result);
isc_loopmgr_setup(loopmgr, sendquery, task);
isc_loopmgr_setup(loopmgr, sendquery, NULL);
isc_loopmgr_run(loopmgr);
dns_requestmgr_shutdown(requestmgr);

31
bin/tools/mdig.c
View File

@ -85,7 +85,6 @@
#define MAXTRIES 0xffffffff
static isc_mem_t *mctx = NULL;
static isc_task_t *global_task = NULL;
static isc_loopmgr_t *loopmgr = NULL;
static dns_requestmgr_t *requestmgr = NULL;
static const char *batchname = NULL;
@ -186,8 +185,8 @@ rcode_totext(dns_rcode_t rcode) {
}
static void
recvresponse(isc_task_t *task, isc_event_t *event) {
dns_requestevent_t *reqev = (dns_requestevent_t *)event;
recvresponse(void *arg) {
dns_request_t *request = (dns_request_t *)arg;
isc_result_t result;
dns_message_t *query = NULL, *response = NULL;
unsigned int parseflags = 0;
@ -197,14 +196,12 @@ recvresponse(isc_task_t *task, isc_event_t *event) {
unsigned int styleflags = 0;
dns_messagetextflag_t flags;
UNUSED(task);
query = dns_request_getarg(request);
REQUIRE(reqev != NULL);
query = reqev->ev_arg;
if (reqev->result != ISC_R_SUCCESS) {
result = dns_request_getresult(request);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "response failed with %s\n",
isc_result_totext(reqev->result));
isc_result_totext(result));
if (continue_on_error) {
goto cleanup;
} else {
@ -220,8 +217,8 @@ recvresponse(isc_task_t *task, isc_event_t *event) {
parseflags |= DNS_MESSAGEPARSE_IGNORETRUNCATION;
}
msgbuf = dns_request_getanswer(reqev->request);
result = dns_request_getresponse(reqev->request, response, parseflags);
msgbuf = dns_request_getanswer(request);
result = dns_request_getresponse(request, response, parseflags);
CHECK("dns_request_getresponse", result);
styleflags |= DNS_STYLEFLAG_REL_OWNER;
@ -541,11 +538,9 @@ cleanup:
if (response != NULL) {
dns_message_detach(&response);
}
dns_request_destroy(&reqev->request);
isc_event_free(&event);
dns_request_destroy(&request);
if (--onfly == 0) {
isc_task_detach(&global_task);
isc_loopmgr_shutdown(loopmgr);
}
return;
@ -754,8 +749,8 @@ sendquery(struct query *query) {
result = dns_request_create(
requestmgr, message, have_src ? &srcaddr : NULL, &dstaddr, NULL,
NULL, options, NULL, query->timeout, query->udptimeout,
query->udpretries, global_task, recvresponse, message,
&request);
query->udpretries, isc_loop_main(loopmgr), recvresponse,
message, &request);
CHECK("dns_request_create", result);
return (ISC_R_SUCCESS);
@ -773,7 +768,6 @@ sendqueries(void *arg) {
}
if (onfly == 0) {
isc_task_detach(&global_task);
isc_loopmgr_shutdown(loopmgr);
}
}
@ -2135,7 +2129,6 @@ main(int argc, char *argv[]) {
fatal("can't choose between IPv4 and IPv6");
}
RUNCHECK(isc_task_create(taskmgr, &global_task, 0));
RUNCHECK(dns_dispatchmgr_create(mctx, netmgr, &dispatchmgr));
set_source_ports(dispatchmgr);
@ -2149,7 +2142,7 @@ main(int argc, char *argv[]) {
dispatchmgr, have_src ? &srcaddr : &bind_any, &dispatchvx));
RUNCHECK(dns_requestmgr_create(
mctx, taskmgr, dispatchmgr, have_ipv4 ? dispatchvx : NULL,
mctx, dispatchmgr, have_ipv4 ? dispatchvx : NULL,
have_ipv6 ? dispatchvx : NULL, &requestmgr));
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_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_result_t
dns_requestmgr_create(isc_mem_t *mctx, isc_taskmgr_t *taskmgr,
dns_dispatchmgr_t *dispatchmgr,
dns_requestmgr_create(isc_mem_t *mctx, dns_dispatchmgr_t *dispatchmgr,
dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6,
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 'taskmgr' is a valid task manager.
*
*\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.
@ -135,7 +126,7 @@ dns_request_create(dns_requestmgr_t *requestmgr, dns_message_t *message,
isc_tlsctx_cache_t *tlsctx_cache, unsigned int options,
dns_tsigkey_t *key, unsigned int timeout,
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);
/*%<
* 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.
*
*\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:
*
@ -170,7 +161,7 @@ dns_request_create(dns_requestmgr_t *requestmgr, dns_message_t *message,
*
*\li 'timeout' > 0
*
*\li 'task' is a valid task.
*\li 'loop' is a valid loop.
*
*\li requestp != NULL && *requestp == NULL
*/
@ -182,9 +173,8 @@ dns_request_createraw(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
dns_transport_t *transport,
isc_tlsctx_cache_t *tlsctx_cache, unsigned int options,
unsigned int timeout, unsigned int udptimeout,
unsigned int udpretries, isc_task_t *task,
isc_taskaction_t action, void *arg,
dns_request_t **requestp);
unsigned int udpretries, isc_loop_t *loop, isc_job_cb cb,
void *arg, dns_request_t **requestp);
/*!<
* \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.
*
*\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:
*
@ -212,7 +202,7 @@ dns_request_createraw(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
*
*\li 'timeout' > 0
*
*\li 'task' is a valid task.
*\li 'loop' is a valid loop.
*
*\li requestp != NULL && *requestp == NULL
*/
@ -299,4 +289,19 @@ dns_request_destroy(dns_request_t **requestp);
*\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

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

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

162
lib/dns/request.c
View File

@ -16,11 +16,12 @@
#include <inttypes.h>
#include <stdbool.h>
#include <isc/async.h>
#include <isc/loop.h>
#include <isc/magic.h>
#include <isc/mem.h>
#include <isc/netmgr.h>
#include <isc/result.h>
#include <isc/task.h>
#include <isc/thread.h>
#include <isc/tls.h>
#include <isc/util.h>
@ -28,7 +29,6 @@
#include <dns/acl.h>
#include <dns/compress.h>
#include <dns/dispatch.h>
#include <dns/events.h>
#include <dns/log.h>
#include <dns/message.h>
#include <dns/rdata.h>
@ -55,7 +55,6 @@ struct dns_requestmgr {
isc_mem_t *mctx;
/* locked */
isc_taskmgr_t *taskmgr;
dns_dispatchmgr_t *dispatchmgr;
dns_dispatch_t *dispatchv4;
dns_dispatch_t *dispatchv6;
@ -72,10 +71,14 @@ struct dns_request {
unsigned int hash;
isc_mem_t *mctx;
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_buffer_t *query;
isc_buffer_t *answer;
dns_requestevent_t *event;
dns_dispatch_t *dispatch;
dns_dispentry_t *dispentry;
dns_requestmgr_t *requestmgr;
@ -115,10 +118,6 @@ req_sendevent(dns_request_t *request, isc_result_t result);
static void
req_connected(isc_result_t eresult, isc_region_t *region, void *arg);
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);
static void
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
dns_requestmgr_create(isc_mem_t *mctx, isc_taskmgr_t *taskmgr,
dns_dispatchmgr_t *dispatchmgr,
dns_requestmgr_create(isc_mem_t *mctx, dns_dispatchmgr_t *dispatchmgr,
dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6,
dns_requestmgr_t **requestmgrp) {
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");
REQUIRE(requestmgrp != NULL && *requestmgrp == NULL);
REQUIRE(taskmgr != NULL);
REQUIRE(dispatchmgr != NULL);
requestmgr = isc_mem_get(mctx, sizeof(*requestmgr));
*requestmgr = (dns_requestmgr_t){ 0 };
isc_taskmgr_attach(taskmgr, &requestmgr->taskmgr);
dns_dispatchmgr_attach(dispatchmgr, &requestmgr->dispatchmgr);
isc_mutex_init(&requestmgr->lock);
@ -259,9 +255,6 @@ mgr_destroy(dns_requestmgr_t *requestmgr) {
if (requestmgr->dispatchmgr != NULL) {
dns_dispatchmgr_detach(&requestmgr->dispatchmgr);
}
if (requestmgr->taskmgr != NULL) {
isc_taskmgr_detach(&requestmgr->taskmgr);
}
requestmgr->magic = 0;
isc_mem_putanddetach(&requestmgr->mctx, requestmgr,
sizeof(*requestmgr));
@ -290,7 +283,7 @@ req_send(dns_request_t *request) {
request->flags |= DNS_REQUEST_F_SENDING;
/* detached in req_senddone() */
req_attach(request, &(dns_request_t *){ NULL });
dns_request_ref(request);
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,
isc_tlsctx_cache_t *tlsctx_cache, unsigned int options,
unsigned int timeout, unsigned int udptimeout,
unsigned int udpretries, isc_task_t *task,
isc_taskaction_t action, void *arg,
dns_request_t **requestp) {
unsigned int udpretries, isc_loop_t *loop, isc_job_cb cb,
void *arg, dns_request_t **requestp) {
dns_request_t *request = NULL;
isc_result_t result;
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(msgbuf != NULL);
REQUIRE(destaddr != NULL);
REQUIRE(task != NULL);
REQUIRE(action != NULL);
REQUIRE(loop != NULL);
REQUIRE(cb != NULL);
REQUIRE(requestp != NULL && *requestp == NULL);
REQUIRE(timeout > 0);
if (srcaddr != NULL) {
@ -451,16 +443,12 @@ dns_request_createraw(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
return (result);
}
request->loop = loop;
request->cb = cb;
request->arg = arg;
request->result = ISC_R_FAILURE;
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);
if (r.length < DNS_MESSAGE_HEADERLEN || r.length > 65535) {
result = DNS_R_FORMERR;
@ -487,7 +475,7 @@ dns_request_createraw(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
}
/* detached in req_connected() */
req_attach(request, &(dns_request_t *){ NULL });
dns_request_ref(request);
again:
@ -549,13 +537,11 @@ unlink:
UNLOCK(&requestmgr->lock);
detach:
/* connect failed, detach here */
req_detach(&(dns_request_t *){ request });
/* connect failed, unref here */
dns_request_unref(request);
cleanup:
isc_task_detach(&(isc_task_t *){ task });
/* final detach to shut down request */
req_detach(&request);
dns_request_detach(&request);
req_log(ISC_LOG_DEBUG(3), "dns_request_createraw: failed %s",
isc_result_totext(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,
dns_tsigkey_t *key, unsigned int timeout,
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 *request = NULL;
isc_result_t result;
@ -580,8 +566,8 @@ dns_request_create(dns_requestmgr_t *requestmgr, dns_message_t *message,
REQUIRE(VALID_REQUESTMGR(requestmgr));
REQUIRE(message != NULL);
REQUIRE(destaddr != NULL);
REQUIRE(task != NULL);
REQUIRE(action != NULL);
REQUIRE(loop != NULL);
REQUIRE(cb != NULL);
REQUIRE(requestp != NULL && *requestp == NULL);
REQUIRE(timeout > 0);
@ -609,15 +595,13 @@ dns_request_create(dns_requestmgr_t *requestmgr, dns_message_t *message,
return (result);
}
request->loop = loop;
request->cb = cb;
request->arg = arg;
request->result = ISC_R_FAILURE;
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;
request->udpcount = udpretries;
if (key != NULL) {
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() */
req_attach(request, &(dns_request_t *){ NULL });
dns_request_ref(request);
again:
result = get_dispatch(tcp, false, requestmgr, srcaddr, destaddr,
@ -691,8 +675,8 @@ again:
if (tcp && connected) {
req_send(request);
/* no need to call req_connected(), detach here */
req_detach(&(dns_request_t *){ request });
/* no need to call req_connected(), unref here */
dns_request_unref(request);
} else {
request->flags |= DNS_REQUEST_F_CONNECTING;
if (tcp) {
@ -715,13 +699,11 @@ unlink:
UNLOCK(&requestmgr->lock);
detach:
/* connect failed, detach here */
req_detach(&(dns_request_t *){ request });
/* connect failed, unref here */
dns_request_unref(request);
cleanup:
isc_task_detach(&(isc_task_t *){ task });
/* final detach to shut down request */
req_detach(&request);
dns_request_detach(&request);
req_log(ISC_LOG_DEBUG(3), "dns_request_create: failed %s",
isc_result_totext(result));
return (result);
@ -887,7 +869,7 @@ dns_request_usedtcp(dns_request_t *request) {
void
dns_request_destroy(dns_request_t **requestp) {
dns_request_t *request;
dns_request_t *request = NULL;
REQUIRE(requestp != NULL && VALID_REQUEST(*requestp));
@ -909,8 +891,16 @@ dns_request_destroy(dns_request_t **requestp) {
INSIST(request->dispentry == 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 */
req_detach(&request);
dns_request_detach(&request);
}
static void
@ -944,7 +934,7 @@ req_connected(isc_result_t eresult, isc_region_t *region, void *arg) {
UNLOCK(&request->requestmgr->locks[request->hash]);
/* attached in dns_request_create/_createraw() */
req_detach(&(dns_request_t *){ request });
dns_request_unref(request);
}
static void
@ -975,7 +965,7 @@ req_senddone(isc_result_t eresult, isc_region_t *region, void *arg) {
UNLOCK(&request->requestmgr->locks[request->hash]);
/* attached in req_send() */
req_detach(&request);
dns_request_detach(&request);
}
static void
@ -1041,53 +1031,26 @@ done:
static void
req_sendevent(dns_request_t *request, isc_result_t result) {
isc_task_t *task = NULL;
REQUIRE(VALID_REQUEST(request));
if (request->event == NULL) {
if (request->complete) {
return;
}
req_log(ISC_LOG_DEBUG(3), "req_sendevent: request %p", request);
/*
* Lock held by caller.
*/
task = request->event->ev_sender;
request->event->ev_sender = request;
request->event->result = result;
dns_request_ref(request);
isc_task_sendanddetach(&task, (isc_event_t **)&request->event);
}
request->result = result;
request->complete = true;
static void
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);
}
isc_async_run(request->loop, request->cb, request);
}
static void
req_destroy(dns_request_t *request) {
REQUIRE(VALID_REQUEST(request));
REQUIRE(!ISC_LINK_LINKED(request, link));
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) {
isc_buffer_free(&request->answer);
}
if (request->event != NULL) {
isc_event_free((isc_event_t **)&request->event);
}
if (request->dispentry != NULL) {
dns_dispatch_done(&request->dispentry);
}
@ -1121,6 +1081,22 @@ req_destroy(dns_request_t *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
req_log(int level, const char *fmt, ...) {
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));
}
isc_taskmgr_t *
dns_resolver_taskmgr(dns_resolver_t *resolver) {
REQUIRE(VALID_RESOLVER(resolver));
return (resolver->taskmgr);
}
uint32_t
dns_resolver_getlamettl(dns_resolver_t *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(
view->mctx, dns_resolver_taskmgr(view->resolver),
dns_resolver_dispatchmgr(view->resolver), dispatchv4,
dispatchv6, &view->requestmgr);
view->mctx, dns_resolver_dispatchmgr(view->resolver),
dispatchv4, dispatchv6, &view->requestmgr);
if (result != ISC_R_SUCCESS) {
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
zone_send_secureserial(dns_zone_t *zone, uint32_t serial);
static void
refresh_callback(isc_task_t *, isc_event_t *);
refresh_callback(void *arg);
static void
stub_callback(isc_task_t *, isc_event_t *);
stub_callback(void *arg);
static void
queue_soa_query(dns_zone_t *zone);
static void
@ -895,7 +895,7 @@ checkds_send(dns_zone_t *zone);
static void
checkds_createmessage(dns_zone_t *zone, dns_message_t **messagep);
static void
checkds_done(isc_task_t *task, isc_event_t *event);
checkds_done(void *arg);
static void
checkds_send_toaddr(void *arg);
static void
@ -908,7 +908,7 @@ static isc_result_t
notify_createmessage(dns_zone_t *zone, unsigned int flags,
dns_message_t **messagep);
static void
notify_done(isc_task_t *task, isc_event_t *event);
notify_done(void *arg);
static void
notify_send_toaddr(void *arg);
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
zone_freedbargs(dns_zone_t *zone);
static void
forward_callback(isc_task_t *task, isc_event_t *event);
forward_callback(void *arg);
static void
zone_saveunique(dns_zone_t *zone, const char *path, const char *templat);
static void
@ -12297,7 +12297,7 @@ notify_send_toaddr(void *arg) {
result = dns_request_create(
notify->zone->view->requestmgr, message, &src, &notify->dst,
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 (isc_sockaddr_pf(&notify->dst) == AF_INET) {
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.
*/
static void
stub_glue_response_cb(isc_task_t *task, isc_event_t *event) {
dns_requestevent_t *revent = (dns_requestevent_t *)event;
dns_stub_t *stub = NULL;
stub_glue_response(void *arg) {
dns_request_t *request = (dns_request_t *)arg;
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_zone_t *zone = NULL;
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_sockaddr_t curraddr;
isc_time_t now;
struct stub_glue_request *request;
struct stub_cb_args *cb_args;
dns_rdataset_t *addr_rdataset = 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));
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(&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,
&zone->sourceaddr, &now);
dns_zone_log(zone, ISC_LOG_INFO,
"could not refresh stub from primary %s"
" (source %s): %s",
primary, source,
isc_result_totext(revent->result));
isc_result_totext(dns_request_getresult(request)));
goto cleanup;
}
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) {
dns_zone_log(zone, ISC_LOG_INFO,
"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.
*/
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,
"refreshing stub: truncated TCP "
"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);
addr_count = message_count(msg, DNS_SECTION_ANSWER,
request->ipv4 ? dns_rdatatype_a
: dns_rdatatype_aaaa);
sgr->ipv4 ? dns_rdatatype_a
: dns_rdatatype_aaaa);
if (cnamecnt != 0) {
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,
"refreshing stub: no %s records in response "
"from primary %s (source %s)",
request->ipv4 ? "A" : "AAAA", primary, source);
sgr->ipv4 ? "A" : "AAAA", primary, source);
goto cleanup;
}
/*
* Extract A or AAAA RRset from message.
*/
result = dns_message_findname(msg, DNS_SECTION_ANSWER, &request->name,
request->ipv4 ? dns_rdatatype_a
: dns_rdatatype_aaaa,
result = dns_message_findname(msg, DNS_SECTION_ANSWER, &sgr->name,
sgr->ipv4 ? dns_rdatatype_a
: dns_rdatatype_aaaa,
dns_rdatatype_none, NULL, &addr_rdataset);
if (result != ISC_R_SUCCESS) {
if (result != DNS_R_NXDOMAIN && result != DNS_R_NXRRSET) {
char namebuf[DNS_NAME_FORMATSIZE];
dns_name_format(&request->name, namebuf,
sizeof(namebuf));
dns_name_format(&sgr->name, namebuf, sizeof(namebuf));
dns_zone_log(
zone, ISC_LOG_INFO,
"refreshing stub: dns_message_findname(%s/%s) "
"failed (%s)",
namebuf, request->ipv4 ? "A" : "AAAA",
namebuf, sgr->ipv4 ? "A" : "AAAA",
isc_result_totext(result));
}
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) {
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: "
@ -12957,10 +12951,8 @@ cleanup:
if (msg != NULL) {
dns_message_detach(&msg);
}
isc_event_free(&event);
dns_name_free(&request->name, zone->mctx);
dns_request_destroy(&request->request);
isc_mem_put(zone->mctx, request, sizeof(*request));
dns_name_free(&sgr->name, zone->mctx);
dns_request_destroy(&request);
/* If last request, release all related resources */
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(
zone->view->requestmgr, message, &zone->sourceaddr, &curraddr,
NULL, NULL, DNS_REQUESTOPT_TCP, args->tsig_key,
args->timeout * 3, args->timeout, 2, zone->task,
stub_glue_response_cb, request, &request->request);
args->timeout * 3, args->timeout, 2, zone->loop,
stub_glue_response, request, &request->request);
if (result != ISC_R_SUCCESS) {
uint_fast32_t pr;
@ -13196,9 +13188,10 @@ done:
}
static void
stub_callback(isc_task_t *task, isc_event_t *event) {
dns_requestevent_t *revent = (dns_requestevent_t *)event;
dns_stub_t *stub = NULL;
stub_callback(void *arg) {
dns_request_t *request = (dns_request_t *)arg;
struct stub_cb_args *cb_args = dns_request_getarg(request);
dns_stub_t *stub = cb_args->stub;
dns_message_t *msg = NULL;
dns_zone_t *zone = NULL;
char primary[ISC_SOCKADDR_FORMATSIZE];
@ -13208,14 +13201,9 @@ stub_callback(isc_task_t *task, isc_event_t *event) {
isc_sockaddr_t curraddr;
isc_time_t now;
bool exiting = false;
struct stub_cb_args *cb_args;
cb_args = revent->ev_arg;
stub = cb_args->stub;
INSIST(DNS_STUB_VALID(stub));
UNUSED(task);
zone = stub->zone;
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(&zone->sourceaddr, source, sizeof(source));
switch (revent->result) {
result = dns_request_getresult(request);
switch (result) {
case ISC_R_SUCCESS:
break;
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,
"could not refresh stub from primary "
"%s (source %s): %s",
primary, source,
isc_result_totext(revent->result));
primary, source, isc_result_totext(result));
goto next_primary;
}
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) {
goto next_primary;
}
@ -13316,7 +13304,7 @@ stub_callback(isc_task_t *task, isc_event_t *event) {
* We need complete messages.
*/
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,
"refreshing stub: truncated TCP "
"response from primary %s (source %s)",
@ -13377,7 +13365,6 @@ stub_callback(isc_task_t *task, isc_event_t *event) {
}
dns_message_detach(&msg);
isc_event_free(&event);
dns_request_destroy(&zone->request);
/*
@ -13408,7 +13395,6 @@ next_primary:
if (msg != NULL) {
dns_message_detach(&msg);
}
isc_event_free(&event);
dns_request_destroy(&zone->request);
/*
* Skip to next failed / untried primary.
@ -13428,11 +13414,10 @@ same_primary:
if (msg != NULL) {
dns_message_detach(&msg);
}
isc_event_free(&event);
dns_request_destroy(&zone->request);
ns_query(zone, NULL, stub);
UNLOCK_ZONE(zone);
goto done;
return;
free_stub:
UNLOCK_ZONE(zone);
@ -13441,10 +13426,6 @@ free_stub:
INSIST(stub->db == NULL);
INSIST(stub->version == NULL);
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).
*/
static void
refresh_callback(isc_task_t *task, isc_event_t *event) {
dns_requestevent_t *revent = (dns_requestevent_t *)event;
dns_zone_t *zone;
refresh_callback(void *arg) {
dns_request_t *request = (dns_request_t *)arg;
dns_zone_t *zone = dns_request_getarg(request);
dns_message_t *msg = NULL;
uint32_t soacnt, cnamecnt, soacount, nscount;
isc_time_t now;
@ -13557,11 +13538,8 @@ refresh_callback(isc_task_t *task, isc_event_t *event) {
uint32_t serial, oldserial = 0;
bool do_queue_xfrin = false;
zone = revent->ev_arg;
INSIST(DNS_ZONE_VALID(zone));
UNUSED(task);
ENTER;
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(&zone->sourceaddr, source, sizeof(source));
switch (revent->result) {
switch (dns_request_getresult(request)) {
case ISC_R_SUCCESS:
break;
case ISC_R_SHUTTINGDOWN:
@ -13592,7 +13570,7 @@ refresh_callback(isc_task_t *task, isc_event_t *event) {
"primary %s (source %s)",
primary, source);
goto same_primary;
} else if (!dns_request_usedtcp(revent->request)) {
} else if (!dns_request_usedtcp(request)) {
dns_zone_log(zone, ISC_LOG_INFO,
"refresh: retry limit for "
"primary %s exceeded (source %s)",
@ -13626,12 +13604,12 @@ refresh_callback(isc_task_t *task, isc_event_t *event) {
"refresh: failure trying primary "
"%s (source %s): %s",
primary, source,
isc_result_totext(revent->result));
isc_result_totext(dns_request_getresult(request)));
goto next_primary;
}
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) {
dns_zone_log(zone, ISC_LOG_INFO,
"refresh: failure trying primary "
@ -13724,7 +13702,7 @@ refresh_callback(isc_task_t *task, isc_event_t *event) {
goto tcp_transfer;
} else {
INSIST(zone->type == dns_zone_stub);
if (dns_request_usedtcp(revent->request)) {
if (dns_request_usedtcp(request)) {
dns_zone_log(zone, ISC_LOG_INFO,
"refresh: truncated TCP response "
"from primary %s (source %s)",
@ -13856,7 +13834,6 @@ refresh_callback(isc_task_t *task, isc_event_t *event) {
goto next_primary;
}
tcp_transfer:
isc_event_free(&event);
dns_request_destroy(&zone->request);
if (zone->type == dns_zone_secondary ||
zone->type == dns_zone_mirror ||
@ -13915,7 +13892,6 @@ next_primary:
if (msg != NULL) {
dns_message_detach(&msg);
}
isc_event_free(&event);
dns_request_destroy(&zone->request);
/*
* Skip to next failed / untried primary.
@ -13936,7 +13912,6 @@ next_primary:
goto detach;
exiting:
isc_event_free(&event);
dns_request_destroy(&zone->request);
goto detach;
@ -13944,7 +13919,6 @@ same_primary:
if (msg != NULL) {
dns_message_detach(&msg);
}
isc_event_free(&event);
dns_request_destroy(&zone->request);
queue_soa_query(zone);
@ -14169,7 +14143,7 @@ again:
}
result = dns_request_create(
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);
if (result != ISC_R_SUCCESS) {
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(
zone->view->requestmgr, message, &zone->sourceaddr, &curraddr,
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) {
zone_debuglog(zone, __func__, 1,
"dns_request_create() failed: %s",
@ -15757,32 +15731,28 @@ dns_zone_getidleout(dns_zone_t *zone) {
}
static void
notify_done(isc_task_t *task, isc_event_t *event) {
dns_requestevent_t *revent = (dns_requestevent_t *)event;
dns_notify_t *notify;
notify_done(void *arg) {
dns_request_t *request = (dns_request_t *)arg;
dns_notify_t *notify = dns_request_getarg(request);
isc_result_t result;
dns_message_t *message = NULL;
isc_buffer_t buf;
char rcode[128];
char addrbuf[ISC_SOCKADDR_FORMATSIZE];
UNUSED(task);
notify = event->ev_arg;
REQUIRE(DNS_NOTIFY_VALID(notify));
INSIST(task == notify->zone->task);
isc_buffer_init(&buf, rcode, sizeof(rcode));
isc_sockaddr_format(&notify->dst, addrbuf, sizeof(addrbuf));
dns_message_create(notify->zone->mctx, DNS_MESSAGE_INTENTPARSE,
&message);
if (revent->result != ISC_R_SUCCESS) {
result = revent->result;
result = dns_request_getresult(request);
if (result != ISC_R_SUCCESS) {
goto fail;
}
result = dns_request_getresponse(revent->request, message,
result = dns_request_getresponse(request, message,
DNS_MESSAGEPARSE_PRESERVEORDER);
if (result != ISC_R_SUCCESS) {
goto fail;
@ -15806,7 +15776,6 @@ fail:
}
done:
notify_destroy(notify, false);
isc_event_free(&event);
dns_message_detach(&message);
}
@ -17708,7 +17677,7 @@ sendtoprimary(dns_forward_t *forward) {
result = dns_request_createraw(
forward->zone->view->requestmgr, forward->msgbuf, &src,
&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);
if (result == ISC_R_SUCCESS) {
if (!ISC_LINK_LINKED(forward, link)) {
@ -17730,17 +17699,14 @@ unlock:
}
static void
forward_callback(isc_task_t *task, isc_event_t *event) {
dns_requestevent_t *revent = (dns_requestevent_t *)event;
forward_callback(void *arg) {
dns_request_t *request = (dns_request_t *)arg;
dns_forward_t *forward = dns_request_getarg(request);
dns_message_t *msg = NULL;
char primary[ISC_SOCKADDR_FORMATSIZE];
isc_result_t result;
dns_forward_t *forward;
dns_zone_t *zone;
UNUSED(task);
forward = revent->ev_arg;
INSIST(DNS_FORWARD_VALID(forward));
zone = forward->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));
if (revent->result != ISC_R_SUCCESS) {
result = dns_request_getresult(request);
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_INFO,
"could not forward dynamic update to %s: %s",
primary, isc_result_totext(revent->result));
primary, isc_result_totext(result));
goto next_primary;
}
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_CLONEBUFFER);
if (result != ISC_R_SUCCESS) {
@ -17833,14 +17800,12 @@ forward_callback(isc_task_t *task, isc_event_t *event) {
msg = NULL;
dns_request_destroy(&forward->request);
forward_destroy(forward);
isc_event_free(&event);
return;
next_primary:
if (msg != NULL) {
dns_message_detach(&msg);
}
isc_event_free(&event);
forward->which++;
dns_request_destroy(&forward->request);
result = sendtoprimary(forward);
@ -18089,9 +18054,7 @@ dns_zonemgr_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
ISC_MEM_ZERO);
for (size_t i = 0; i < zmgr->workers; i++) {
result = isc_task_create(zmgr->taskmgr, &zmgr->zonetasks[i], i);
INSIST(result == ISC_R_SUCCESS);
if (result != ISC_R_SUCCESS) {
INSIST(result == ISC_R_SUCCESS);
goto free_zonetasks;
}
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
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 rcode[128];
dns_checkds_t *checkds;
dns_zone_t *zone;
dns_zone_t *zone = NULL;
dns_db_t *db = NULL;
dns_dbversion_t *version = NULL;
dns_dnsseckey_t *key;
dns_dnsseckey_t *key = NULL;
dns_dnsseckeylist_t keys;
dns_kasp_t *kasp = NULL;
dns_message_t *message = NULL;
dns_rdataset_t *ds_rrset = NULL;
dns_requestevent_t *revent = (dns_requestevent_t *)event;
isc_buffer_t buf;
isc_result_t result;
isc_stdtime_t now;
@ -19840,13 +19803,9 @@ checkds_done(isc_task_t *task, isc_event_t *event) {
bool rekey = false;
bool empty = false;
UNUSED(task);
checkds = event->ev_arg;
REQUIRE(DNS_CHECKDS_VALID(checkds));
zone = checkds->zone;
INSIST(task == zone->task);
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);
INSIST(message != NULL);
CHECK(revent->result);
CHECK(dns_request_getresponse(revent->request, message,
CHECK(dns_request_getresult(request));
CHECK(dns_request_getresponse(request, message,
DNS_MESSAGEPARSE_PRESERVEORDER));
CHECK(dns_rcode_totext(message->rcode, &buf));
@ -20055,7 +20014,6 @@ failure:
dns_dnsseckey_destroy(dns_zone_getmctx(zone), &key);
}
isc_event_free(&event);
checkds_destroy(checkds, false);
dns_message_detach(&message);
}
@ -20261,7 +20219,7 @@ checkds_send_toaddr(void *arg) {
result = dns_request_create(
checkds->zone->view->requestmgr, message, &src, &checkds->dst,
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) {
dns_zone_log(checkds->zone, ISC_LOG_DEBUG(3),
"checkds: dns_request_create() to %s failed: %s",