2000-02-24 14:31:43 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2000 Internet Software Consortium.
|
|
|
|
*
|
|
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
|
|
* copyright notice and this permission notice appear in all copies.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
|
|
|
|
* ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
|
|
|
|
* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
|
|
|
|
* CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
|
|
|
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
|
|
|
|
* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
|
|
|
* SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <config.h>
|
|
|
|
|
2000-03-13 20:43:39 +00:00
|
|
|
#include <isc/assertions.h>
|
|
|
|
#include <isc/buffer.h>
|
|
|
|
#include <isc/event.h>
|
|
|
|
#include <isc/net.h>
|
|
|
|
#include <isc/mutex.h>
|
|
|
|
#include <isc/region.h>
|
|
|
|
#include <isc/socket.h>
|
|
|
|
#include <isc/task.h>
|
|
|
|
#include <isc/timer.h>
|
|
|
|
#include <isc/util.h>
|
|
|
|
|
|
|
|
#include <dns/dispatch.h>
|
|
|
|
#include <dns/events.h>
|
|
|
|
#include <dns/message.h>
|
2000-02-24 14:31:43 +00:00
|
|
|
#include <dns/request.h>
|
|
|
|
|
|
|
|
#define REQUESTMGR_MAGIC 0x12341234U /* XXX MPA */
|
|
|
|
#define VALID_REQUESTMGR(mgr) ((mgr) != NULL && \
|
|
|
|
(mgr)->magic == REQUESTMGR_MAGIC)
|
|
|
|
|
|
|
|
#define REQUEST_MAGIC 0x12341235U /* XXX MPA */
|
|
|
|
#define VALID_REQUEST(request) ((request) != NULL && \
|
|
|
|
(request)->magic == REQUEST_MAGIC)
|
|
|
|
|
|
|
|
struct dns_requestmgr {
|
|
|
|
isc_int32_t magic;
|
|
|
|
isc_mutex_t lock;
|
|
|
|
isc_mem_t *mctx;
|
|
|
|
|
|
|
|
/* locked */
|
|
|
|
isc_int32_t references;
|
|
|
|
isc_timermgr_t *timermgr;
|
|
|
|
dns_dispatch_t *dispatchv4;
|
|
|
|
dns_dispatch_t *dispatchv6;
|
|
|
|
isc_boolean_t exiting;
|
|
|
|
isc_eventlist_t whenshutdown;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct dns_request {
|
2000-03-13 20:43:39 +00:00
|
|
|
isc_int32_t magic;
|
|
|
|
isc_mem_t *mctx;
|
|
|
|
isc_task_t *task;
|
|
|
|
isc_taskaction_t action;
|
|
|
|
void *action_arg;
|
|
|
|
isc_buffer_t *query;
|
|
|
|
isc_buffer_t *answer;
|
|
|
|
dns_requestevent_t *event;
|
|
|
|
dns_dispentry_t *dispentry;
|
|
|
|
dns_messageid_t id;
|
|
|
|
};
|
2000-02-24 14:31:43 +00:00
|
|
|
|
|
|
|
/***
|
|
|
|
*** Forward
|
|
|
|
***/
|
|
|
|
|
2000-03-13 20:43:39 +00:00
|
|
|
static void destroy(dns_requestmgr_t *requestmgr);
|
2000-02-24 14:31:43 +00:00
|
|
|
static void send_shutdown_events(dns_requestmgr_t *requestmgr);
|
2000-03-13 20:43:39 +00:00
|
|
|
static isc_result_t render(dns_message_t *message, isc_buffer_t **buffer,
|
|
|
|
isc_mem_t *mctx);
|
|
|
|
static void senddone(isc_task_t *task, isc_event_t *event);
|
|
|
|
static void response(isc_task_t *task, isc_event_t *event);
|
2000-02-24 14:31:43 +00:00
|
|
|
|
|
|
|
/***
|
|
|
|
*** Public
|
|
|
|
***/
|
|
|
|
|
|
|
|
isc_result_t
|
|
|
|
dns_requestmgr_create(isc_mem_t *mctx, isc_timermgr_t *timermgr,
|
|
|
|
dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6,
|
|
|
|
dns_requestmgr_t **requestmgrp) {
|
|
|
|
dns_requestmgr_t *requestmgr;
|
2000-03-13 20:43:39 +00:00
|
|
|
isc_socket_t *socket;
|
|
|
|
isc_result_t result;
|
2000-02-24 14:31:43 +00:00
|
|
|
|
|
|
|
REQUIRE(requestmgrp != NULL && *requestmgrp == NULL);
|
|
|
|
if (dispatchv4 != NULL) {
|
|
|
|
socket = dns_dispatch_getsocket(dispatchv4);
|
2000-03-13 20:43:39 +00:00
|
|
|
REQUIRE(isc_socket_gettype(socket) == PF_INET);
|
2000-02-24 14:31:43 +00:00
|
|
|
}
|
|
|
|
if (dispatchv6 != NULL) {
|
|
|
|
socket = dns_dispatch_getsocket(dispatchv6);
|
2000-03-13 20:43:39 +00:00
|
|
|
REQUIRE(isc_socket_gettype(socket) == PF_INET6);
|
2000-02-24 14:31:43 +00:00
|
|
|
}
|
|
|
|
REQUIRE(timermgr != NULL);
|
|
|
|
|
|
|
|
requestmgr = isc_mem_get(mctx, sizeof(*requestmgr));
|
|
|
|
if (requestmgr == NULL)
|
|
|
|
return (ISC_R_NOMEMORY);
|
|
|
|
|
2000-03-13 20:43:39 +00:00
|
|
|
result = isc_mutex_init(&requestmgr->lock);
|
2000-02-24 14:31:43 +00:00
|
|
|
if (result != DNS_R_SUCCESS) {
|
|
|
|
isc_mem_put(mctx, requestmgr, sizeof(*requestmgr));
|
|
|
|
return (result);
|
|
|
|
}
|
|
|
|
requestmgr->timermgr = timermgr;
|
|
|
|
requestmgr->dispatchv4 = NULL;
|
2000-03-13 20:43:39 +00:00
|
|
|
if (dispatchv4 != NULL)
|
|
|
|
dns_dispatch_attach(dispatchv4, &requestmgr->dispatchv4);
|
2000-02-24 14:31:43 +00:00
|
|
|
requestmgr->dispatchv6 = NULL;
|
|
|
|
if (dispatchv6 != NULL)
|
2000-03-13 20:43:39 +00:00
|
|
|
dns_dispatch_attach(dispatchv6, &requestmgr->dispatchv6);
|
2000-02-24 14:31:43 +00:00
|
|
|
requestmgr->mctx = mctx;
|
|
|
|
requestmgr->references = 1; /* implict attach */
|
|
|
|
ISC_LIST_INIT(requestmgr->whenshutdown);
|
|
|
|
requestmgr->exiting = ISC_FALSE;
|
|
|
|
requestmgr->magic = REQUESTMGR_MAGIC;
|
|
|
|
*requestmgrp = requestmgr;
|
|
|
|
|
|
|
|
return (ISC_R_SUCCESS);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dns_requestmgr_whenshutdown(dns_requestmgr_t *requestmgr, isc_task_t *task,
|
|
|
|
isc_event_t **eventp)
|
|
|
|
{
|
|
|
|
isc_task_t *clone;
|
|
|
|
isc_event_t *event;
|
|
|
|
|
|
|
|
REQUIRE(VALID_REQUESTMGR(requestmgr));
|
|
|
|
REQUIRE(eventp != NULL);
|
|
|
|
|
|
|
|
event = *eventp;
|
|
|
|
*eventp = NULL;
|
|
|
|
|
|
|
|
LOCK(&requestmgr->lock);
|
|
|
|
|
|
|
|
if (requestmgr->exiting) {
|
|
|
|
/*
|
|
|
|
* We're already shutdown. Send the event.
|
|
|
|
*/
|
|
|
|
event->sender = requestmgr;
|
|
|
|
isc_task_send(task, &event);
|
|
|
|
} else {
|
|
|
|
clone = NULL;
|
|
|
|
isc_task_attach(task, &clone);
|
|
|
|
event->sender = clone;
|
|
|
|
ISC_LIST_APPEND(requestmgr->whenshutdown, event, link);
|
|
|
|
}
|
|
|
|
UNLOCK(&requestmgr->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dns_requestmgr_shutdown(dns_requestmgr_t *requestmgr) {
|
|
|
|
|
|
|
|
REQUIRE(VALID_REQUESTMGR(requestmgr));
|
|
|
|
|
|
|
|
LOCK(&requestmgr->lock);
|
|
|
|
if (!requestmgr->exiting) {
|
|
|
|
requestmgr->exiting = ISC_TRUE;
|
|
|
|
/* XXXMPA shutdown existing requests */
|
|
|
|
send_shutdown_events(requestmgr);
|
|
|
|
}
|
|
|
|
UNLOCK(&requestmgr->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dns_requestmgr_attach(dns_requestmgr_t *source, dns_requestmgr_t **targetp) {
|
|
|
|
|
|
|
|
REQUIRE(VALID_REQUESTMGR(source));
|
|
|
|
REQUIRE(targetp != NULL && *targetp == NULL);
|
|
|
|
|
2000-03-13 20:43:39 +00:00
|
|
|
LOCK(&source->lock);
|
|
|
|
REQUIRE(!source->exiting);
|
2000-02-24 14:31:43 +00:00
|
|
|
|
|
|
|
INSIST(source->references > 0);
|
|
|
|
source->references++;
|
|
|
|
INSIST(source->references != 0);
|
2000-03-13 20:43:39 +00:00
|
|
|
UNLOCK(&source->lock);
|
2000-02-24 14:31:43 +00:00
|
|
|
|
|
|
|
*targetp = source;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dns_requestmgr_detach(dns_requestmgr_t **requestmgrp) {
|
|
|
|
dns_requestmgr_t *requestmgr;
|
|
|
|
isc_boolean_t need_destroy = ISC_FALSE;
|
|
|
|
|
|
|
|
REQUIRE(requestmgrp != NULL);
|
2000-03-13 20:43:39 +00:00
|
|
|
requestmgr = *requestmgrp;
|
2000-02-24 14:31:43 +00:00
|
|
|
REQUIRE(VALID_REQUESTMGR(requestmgr));
|
|
|
|
|
|
|
|
LOCK(&requestmgr->lock);
|
|
|
|
INSIST(requestmgr->references > 0);
|
|
|
|
requestmgr->references--;
|
2000-03-13 20:43:39 +00:00
|
|
|
if (requestmgr->references == 0) {
|
2000-02-24 14:31:43 +00:00
|
|
|
INSIST(requestmgr->exiting);
|
|
|
|
need_destroy = ISC_TRUE;
|
|
|
|
}
|
2000-03-13 20:43:39 +00:00
|
|
|
UNLOCK(&requestmgr->lock);
|
2000-02-24 14:31:43 +00:00
|
|
|
|
|
|
|
if (need_destroy)
|
|
|
|
destroy(requestmgr);
|
|
|
|
|
|
|
|
*requestmgrp = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
send_shutdown_events(dns_requestmgr_t *requestmgr) {
|
|
|
|
isc_event_t *event, *next_event;
|
|
|
|
isc_task_t *etask;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Caller must be holding the manager lock.
|
|
|
|
*/
|
|
|
|
for (event = ISC_LIST_HEAD(requestmgr->whenshutdown);
|
|
|
|
event != NULL;
|
|
|
|
event = next_event) {
|
|
|
|
next_event = ISC_LIST_NEXT(event, link);
|
2000-03-13 20:43:39 +00:00
|
|
|
ISC_LIST_UNLINK(requestmgr->whenshutdown, event, link);
|
2000-02-24 14:31:43 +00:00
|
|
|
etask = event->sender;
|
|
|
|
event->sender = requestmgr;
|
|
|
|
isc_task_sendanddetach(&etask, &event);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
destroy(dns_requestmgr_t *requestmgr) {
|
2000-03-13 20:43:39 +00:00
|
|
|
REQUIRE(requestmgr->references == 0);
|
2000-02-24 14:31:43 +00:00
|
|
|
isc_mutex_destroy(&requestmgr->lock);
|
|
|
|
if (requestmgr->dispatchv4 != NULL)
|
|
|
|
dns_dispatch_detach(&requestmgr->dispatchv4);
|
|
|
|
if (requestmgr->dispatchv4 != NULL)
|
|
|
|
dns_dispatch_detach(&requestmgr->dispatchv4);
|
2000-03-13 20:43:39 +00:00
|
|
|
requestmgr->magic = 0;
|
2000-02-24 14:31:43 +00:00
|
|
|
isc_mem_put(requestmgr->mctx, requestmgr, sizeof *requestmgr);
|
|
|
|
}
|
|
|
|
|
|
|
|
isc_result_t
|
|
|
|
dns_request_create(dns_requestmgr_t *requestmgr, dns_message_t *message,
|
|
|
|
isc_sockaddr_t *address, unsigned int options,
|
|
|
|
unsigned int timeout, isc_task_t *task,
|
|
|
|
isc_taskaction_t action, void *arg,
|
|
|
|
dns_request_t **requestp)
|
|
|
|
{
|
2000-03-13 20:43:39 +00:00
|
|
|
dns_request_t *request = NULL;
|
|
|
|
dns_requestevent_t *event = NULL;
|
|
|
|
dns_message_t *answer = NULL;
|
|
|
|
dns_dispatch_t *dispatch = NULL;
|
|
|
|
isc_buffer_t *query = NULL;
|
|
|
|
isc_task_t *tclone = NULL;
|
|
|
|
isc_socket_t *socket = NULL;
|
|
|
|
isc_result_t result;
|
|
|
|
isc_mem_t *mctx;
|
|
|
|
isc_region_t r;
|
2000-02-24 14:31:43 +00:00
|
|
|
|
|
|
|
REQUIRE(VALID_REQUESTMGR(requestmgr));
|
|
|
|
REQUIRE(message != NULL);
|
2000-03-13 20:43:39 +00:00
|
|
|
REQUIRE(address != NULL);
|
2000-02-24 14:31:43 +00:00
|
|
|
REQUIRE(task != NULL);
|
|
|
|
REQUIRE(action != NULL);
|
|
|
|
REQUIRE(requestp != NULL && *requestp == NULL);
|
|
|
|
REQUIRE(timeout > 0);
|
|
|
|
|
2000-03-13 20:43:39 +00:00
|
|
|
mctx = requestmgr->mctx;
|
|
|
|
|
|
|
|
request = isc_mem_get(mctx, sizeof(*request));
|
|
|
|
if (request == NULL) {
|
|
|
|
result = ISC_R_NOMEMORY;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
event = (dns_requestevent_t *)
|
|
|
|
isc_event_allocate(mctx, task, DNS_EVENT_REQUESTDONE,
|
|
|
|
action, arg, sizeof (dns_requestevent_t));
|
|
|
|
if (event == NULL) {
|
|
|
|
result = ISC_R_NOMEMORY;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
isc_task_attach(task, &tclone);
|
|
|
|
event->sender = task;
|
|
|
|
event->request = request;
|
|
|
|
event->result = ISC_R_FAILURE;
|
|
|
|
|
|
|
|
result = dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &answer);
|
|
|
|
if (result == DNS_R_USETCP) {
|
|
|
|
options |= DNS_REQUESTOPT_USETCP;
|
|
|
|
result = ISC_R_SUCCESS;
|
|
|
|
}
|
|
|
|
if (result != ISC_R_SUCCESS)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if ((options & DNS_REQUESTOPT_USETCP) != 0) {
|
|
|
|
/* result = isc_socket_create(requestmgr->socketmgr,
|
|
|
|
isc_sockaddr_pf(address),
|
|
|
|
isc_sockettype_tcp, &socket); */
|
|
|
|
if (result != ISC_R_SUCCESS)
|
|
|
|
goto cleanup;
|
|
|
|
result = dns_dispatch_create(mctx, socket, task,
|
|
|
|
4096, 2, 1, 1, 3, NULL,
|
|
|
|
&dispatch);
|
|
|
|
isc_socket_detach(&socket);
|
|
|
|
if (result != ISC_R_SUCCESS)
|
|
|
|
goto cleanup;
|
|
|
|
} else {
|
|
|
|
switch (isc_sockaddr_pf(address)) {
|
|
|
|
case PF_INET:
|
|
|
|
dns_dispatch_attach(requestmgr->dispatchv4, &dispatch);
|
|
|
|
break;
|
|
|
|
case PF_INET6:
|
|
|
|
dns_dispatch_attach(requestmgr->dispatchv6, &dispatch);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
result = DNS_R_NOTIMPLEMENTED;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
result = dns_dispatch_addresponse(dispatch, address, task,
|
|
|
|
response, request, &request->id,
|
|
|
|
&request->dispentry);
|
|
|
|
if (result != ISC_R_SUCCESS)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
message->id = request->id;
|
|
|
|
result = render(message, &query, mctx);
|
|
|
|
if (result != ISC_R_SUCCESS)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
request->mctx = mctx;
|
|
|
|
request->query = query;
|
|
|
|
request->answer = NULL;
|
|
|
|
request->event = event;
|
2000-02-24 14:31:43 +00:00
|
|
|
request->magic = REQUEST_MAGIC;
|
2000-03-13 20:43:39 +00:00
|
|
|
|
|
|
|
isc_buffer_used(query, &r);
|
|
|
|
result = isc_socket_sendto(socket, &r, task, senddone,
|
|
|
|
request, address, NULL);
|
|
|
|
|
|
|
|
if (result != ISC_R_SUCCESS)
|
|
|
|
goto cleanup;
|
|
|
|
|
2000-02-24 14:31:43 +00:00
|
|
|
return (ISC_R_SUCCESS);
|
2000-03-13 20:43:39 +00:00
|
|
|
|
|
|
|
cleanup:
|
|
|
|
if (request != NULL)
|
|
|
|
isc_mem_put(mctx, request, sizeof *request);
|
|
|
|
if (event != NULL)
|
|
|
|
isc_event_free((isc_event_t **)&event);
|
|
|
|
if (query != NULL)
|
|
|
|
isc_buffer_free(&query);
|
|
|
|
if (answer != NULL)
|
|
|
|
dns_message_destroy(&answer);
|
|
|
|
if (tclone != NULL)
|
|
|
|
isc_task_detach(&tclone);
|
|
|
|
return (result);
|
|
|
|
}
|
|
|
|
|
|
|
|
static isc_result_t
|
|
|
|
render(dns_message_t *message, isc_buffer_t **bufferp, isc_mem_t *mctx) {
|
|
|
|
isc_buffer_t *buf1 = NULL;
|
|
|
|
isc_buffer_t *buf2 = NULL;
|
|
|
|
isc_result_t result;
|
|
|
|
isc_region_t r;
|
|
|
|
|
|
|
|
REQUIRE(bufferp != NULL && *bufferp == NULL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create buffer able to hold largest possible message.
|
|
|
|
*/
|
|
|
|
result = isc_buffer_allocate(mctx, &buf1, 65535,
|
|
|
|
ISC_BUFFERTYPE_BINARY);
|
|
|
|
if (result != ISC_R_SUCCESS)
|
|
|
|
return (result);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Render message.
|
|
|
|
*/
|
|
|
|
result = dns_message_renderbegin(message, buf1);
|
|
|
|
if (result != DNS_R_SUCCESS)
|
|
|
|
goto cleanup;
|
|
|
|
result = dns_message_rendersection(message, DNS_SECTION_QUESTION, 0);
|
|
|
|
if (result != DNS_R_SUCCESS)
|
|
|
|
goto cleanup;
|
|
|
|
result = dns_message_rendersection(message, DNS_SECTION_ANSWER, 0);
|
|
|
|
if (result != DNS_R_SUCCESS)
|
|
|
|
goto cleanup;
|
|
|
|
result = dns_message_rendersection(message, DNS_SECTION_AUTHORITY, 0);
|
|
|
|
if (result != DNS_R_SUCCESS)
|
|
|
|
goto cleanup;
|
|
|
|
result = dns_message_rendersection(message, DNS_SECTION_ADDITIONAL, 0);
|
|
|
|
if (result != DNS_R_SUCCESS)
|
|
|
|
goto cleanup;
|
|
|
|
result = dns_message_renderend(message);
|
|
|
|
if (result != DNS_R_SUCCESS)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy rendered message to exact sized buffer.
|
|
|
|
*/
|
|
|
|
isc_buffer_used(buf1, &r);
|
|
|
|
result = isc_buffer_allocate(mctx, &buf2, r.length +
|
|
|
|
((r.length > 512) ? 2 : 0),
|
|
|
|
ISC_BUFFERTYPE_BINARY);
|
|
|
|
if (result != ISC_R_SUCCESS)
|
|
|
|
goto cleanup;
|
|
|
|
if (r.length > 512) {
|
|
|
|
isc_buffer_putuint16(buf2, (isc_uint16_t)r.length);
|
|
|
|
}
|
|
|
|
result = isc_buffer_copyregion(buf2, &r);
|
|
|
|
if (result != ISC_R_SUCCESS)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Cleanup and return.
|
|
|
|
*/
|
|
|
|
isc_buffer_free(&buf1);
|
|
|
|
*bufferp = buf2;
|
|
|
|
return (ISC_R_SUCCESS);
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
if (buf1 != NULL)
|
|
|
|
isc_buffer_free(&buf1);
|
|
|
|
if (buf2 != NULL)
|
|
|
|
isc_buffer_free(&buf2);
|
|
|
|
return (result);
|
2000-02-24 14:31:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create and send a request.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
*
|
|
|
|
* 'message' will be rendered and sent to 'address'. If the
|
|
|
|
* DNS_REQUESTOPT_TCP option is set, TCP will be used. The request
|
|
|
|
* will timeout after 'timeout' seconds.
|
|
|
|
*
|
|
|
|
* When the request completes, successfully, due to a timeout, or
|
|
|
|
* because it was canceled, a completion event will be sent to 'task'.
|
|
|
|
*
|
|
|
|
* Requires:
|
|
|
|
*
|
|
|
|
* 'message' is a valid DNS message.
|
|
|
|
*
|
|
|
|
* 'address' is a valid sockaddr.
|
|
|
|
*
|
|
|
|
* 'timeout' > 0
|
|
|
|
*
|
|
|
|
* 'task' is a valid task.
|
|
|
|
*
|
|
|
|
* requestp != NULL && *requestp == NULL
|
|
|
|
*/
|
|
|
|
|
|
|
|
isc_result_t
|
|
|
|
dns_request_cancel(dns_request_t *request) {
|
2000-03-13 20:43:39 +00:00
|
|
|
UNUSED(request);
|
|
|
|
|
|
|
|
return (ISC_R_NOTIMPLEMENTED);
|
2000-02-24 14:31:43 +00:00
|
|
|
}
|
2000-03-13 20:43:39 +00:00
|
|
|
|
2000-02-24 14:31:43 +00:00
|
|
|
/*
|
|
|
|
* Cancel 'request'.
|
|
|
|
*
|
|
|
|
* Requires:
|
|
|
|
*
|
|
|
|
* 'request' is a valid request.
|
|
|
|
*
|
|
|
|
* Ensures:
|
|
|
|
*
|
|
|
|
* If the completion event for 'request' has not yet been sent, it
|
|
|
|
* will be sent, and the result code will be ISC_R_CANCELED.
|
|
|
|
*/
|
|
|
|
|
|
|
|
isc_result_t
|
|
|
|
dns_request_getresponse(dns_request_t *request, dns_message_t *message) {
|
2000-03-13 20:43:39 +00:00
|
|
|
REQUIRE(VALID_REQUEST(request));
|
|
|
|
REQUIRE(request->answer != NULL);
|
|
|
|
|
|
|
|
return (dns_message_parse(message, request->answer, ISC_TRUE));
|
2000-02-24 14:31:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dns_request_destroy(dns_request_t **requestp) {
|
2000-03-13 20:43:39 +00:00
|
|
|
UNUSED(requestp);
|
2000-02-24 14:31:43 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Destroy 'request'.
|
|
|
|
*
|
|
|
|
* Requires:
|
|
|
|
*
|
|
|
|
* 'request' is a valid request for which the caller has received the
|
|
|
|
* completion event.
|
|
|
|
*
|
|
|
|
* Ensures:
|
|
|
|
*
|
|
|
|
* *requestp == NULL
|
|
|
|
*/
|
2000-03-13 20:43:39 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
senddone(isc_task_t *task, isc_event_t *event) {
|
|
|
|
isc_socketevent_t *sevent = (isc_socketevent_t *)event;
|
|
|
|
dns_request_t *request = event->arg;
|
|
|
|
|
|
|
|
REQUIRE(event->type == ISC_SOCKEVENT_SENDDONE);
|
|
|
|
|
|
|
|
(void)task;
|
|
|
|
|
|
|
|
/*
|
|
|
|
if (sevent->result != ISC_R_SUCCESS)
|
|
|
|
fctx_cancelquery(&query, NULL, NULL, ISC_FALSE);
|
|
|
|
*/
|
|
|
|
|
|
|
|
isc_event_free(&event);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
response(isc_task_t *task, isc_event_t *event) {
|
|
|
|
isc_result_t result;
|
|
|
|
dns_request_t *request = event->arg;
|
|
|
|
dns_dispatchevent_t *devent = (dns_dispatchevent_t *)event;
|
|
|
|
dns_message_t *message;
|
|
|
|
|
|
|
|
REQUIRE(VALID_REQUEST(request));
|
|
|
|
REQUIRE(event->type == DNS_EVENT_DISPATCH);
|
|
|
|
|
|
|
|
(void)task;
|
|
|
|
if (devent->result != ISC_R_SUCCESS)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* copy buffer
|
|
|
|
*/
|
|
|
|
|
|
|
|
done:
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
timeout(isc_task_t *task, isc_event_t *event) {
|
|
|
|
isc_result_t result;
|
|
|
|
dns_request_t *request = event->arg;
|
|
|
|
|
|
|
|
if (event->type == ISC_TIMEREVENT_LIFE) {
|
|
|
|
} else {
|
|
|
|
}
|
|
|
|
|
|
|
|
isc_event_free(&event);
|
|
|
|
}
|