#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>
#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>
#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>
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;
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
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;
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");
}
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;
dns_message_renderreset(updatemsg);
dns_message_settsigkey(updatemsg, NULL);
send_update(zname, &primary_servers[primary_inuse]);
- isc_event_free(&event);
return;
}
dns_name_init(&tmpzonename, 0);
dns_name_init(&restart_primary, 0);
}
- isc_event_free(&event);
done_update();
}
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) {
}
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;
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;
}
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);
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;
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++;
}
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;
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;
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:");
}
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;
}
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);
more = user_interaction();
isc_loopmgr_nonblocking(loopmgr);
if (!more) {
- isc_task_detach(&global_task);
isc_loopmgr_shutdown(loopmgr);
return;
}
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);
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;
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);
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;
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;
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);
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);
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;
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);
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);
}
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;
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));
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);
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);
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);
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);
}
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;
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));
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);
#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;
}
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;
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 {
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;
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;
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);
}
if (onfly == 0) {
- isc_task_detach(&global_task);
isc_loopmgr_shutdown(loopmgr);
}
}
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);
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));
#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);
/*%<
*
*\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.
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.
* 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:
*
*
*\li 'timeout' > 0
*
- *\li 'task' is a valid task.
+ *\li 'loop' is a valid loop.
*
*\li requestp != NULL && *requestp == NULL
*/
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.
*
* 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:
*
*
*\li 'timeout' > 0
*
- *\li 'task' is a valid task.
+ *\li 'loop' is a valid loop.
*
*\li requestp != NULL && *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
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);
/*%<
#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>
#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>
isc_mem_t *mctx;
/* locked */
- isc_taskmgr_t *taskmgr;
dns_dispatchmgr_t *dispatchmgr;
dns_dispatch_t *dispatchv4;
dns_dispatch_t *dispatchv6;
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;
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);
***/
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;
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);
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));
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);
}
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;
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) {
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;
}
/* detached in req_connected() */
- req_attach(request, &(dns_request_t *){ NULL });
+ dns_request_ref(request);
again:
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);
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;
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);
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);
}
/* detached in req_connected() */
- req_attach(request, &(dns_request_t *){ NULL });
+ dns_request_ref(request);
again:
result = get_dispatch(tcp, false, requestmgr, srcaddr, destaddr,
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) {
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);
void
dns_request_destroy(dns_request_t **requestp) {
- dns_request_t *request;
+ dns_request_t *request = NULL;
REQUIRE(requestp != NULL && VALID_REQUEST(*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
UNLOCK(&request->requestmgr->locks[request->hash]);
/* attached in dns_request_create/_createraw() */
- req_detach(&(dns_request_t *){ request });
+ dns_request_unref(request);
}
static void
UNLOCK(&request->requestmgr->locks[request->hash]);
/* attached in req_send() */
- req_detach(&request);
+ dns_request_detach(&request);
}
static void
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);
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);
}
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;
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));
}
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;
}
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
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
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
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
result = dns_request_create(
notify->zone->view->requestmgr, message, &src, ¬ify->dst,
NULL, NULL, options, key, timeout * 3, timeout, 2,
- notify->zone->task, notify_done, notify, ¬ify->request);
+ notify->zone->loop, notify_done, notify, ¬ify->request);
if (result == ISC_R_SUCCESS) {
if (isc_sockaddr_pf(¬ify->dst) == AF_INET) {
inc_stats(notify->zone,
* 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];
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;
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)",
* 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)",
*/
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,
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: "
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) {
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;
}
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];
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;
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:
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;
}
* 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)",
}
dns_message_detach(&msg);
- isc_event_free(&event);
dns_request_destroy(&zone->request);
/*
if (msg != NULL) {
dns_message_detach(&msg);
}
- isc_event_free(&event);
dns_request_destroy(&zone->request);
/*
* Skip to next failed / untried 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);
INSIST(stub->db == NULL);
INSIST(stub->version == NULL);
isc_mem_put(stub->mctx, stub, sizeof(*stub));
-
-done:
- INSIST(event == NULL);
- return;
}
/*
* 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;
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);
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:
"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)",
"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 "
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)",
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 ||
if (msg != NULL) {
dns_message_detach(&msg);
}
- isc_event_free(&event);
dns_request_destroy(&zone->request);
/*
* Skip to next failed / untried primary.
goto detach;
exiting:
- isc_event_free(&event);
dns_request_destroy(&zone->request);
goto detach;
if (msg != NULL) {
dns_message_detach(&msg);
}
- isc_event_free(&event);
dns_request_destroy(&zone->request);
queue_soa_query(zone);
}
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 });
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",
}
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(¬ify->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;
}
done:
notify_destroy(notify, false);
- isc_event_free(&event);
dns_message_detach(&message);
}
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)) {
}
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));
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) {
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);
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);
}
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;
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);
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));
dns_dnsseckey_destroy(dns_zone_getmctx(zone), &key);
}
- isc_event_free(&event);
checkds_destroy(checkds, false);
dns_message_detach(&message);
}
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",
projects / thirdparty / bind9.git / commitdiff
