lib/dns/dispatch.c

	dispatch.c revision bbf667382840b943a639f2bd09fc3abd52fe9b7a
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley/*
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley * Copyright (C) 1999, 2000  Internet Software Consortium.
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley *
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley * Permission to use, copy, modify, and distribute this software for any
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley * purpose with or without fee is hereby granted, provided that the above
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley * copyright notice and this permission notice appear in all copies.
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley *
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley * SOFTWARE.
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#include <config.h>
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#include <stdlib.h>
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#include <isc/lfsr.h>
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#include <isc/mem.h>
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#include <isc/mutex.h>
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#include <isc/print.h>
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#include <isc/string.h>
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#include <isc/task.h>
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#include <isc/util.h>
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#include <dns/dispatch.h>
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#include <dns/events.h>
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#include <dns/log.h>
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#include <dns/message.h>
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#include <dns/tcpmsg.h>
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#include <dns/types.h>
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystruct dns_dispatchmgr {
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    /* Unlocked. */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    unsigned int            magic;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    isc_mem_t              *mctx;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    /* Locked by "lock". */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    isc_mutex_t         lock;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    unsigned int            state;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    ISC_LIST(dns_dispatch_t)    list;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley};
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#define MGR_SHUTTINGDOWN        0x00000001U
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#define MGR_IS_SHUTTINGDOWN(l)  (((l)->state & MGR_SHUTTINGDOWN) != 0)
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#define IS_PRIVATE(d)   (((d)->attributes & DNS_DISPATCHATTR_PRIVATE) != 0)
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystruct dns_dispentry {
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    unsigned int            magic;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    isc_uint32_t            id;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    unsigned int            bucket;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    isc_sockaddr_t          host;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    isc_task_t             *task;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    isc_taskaction_t        action;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    void                   *arg;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    isc_boolean_t           item_out;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    ISC_LIST(dns_dispatchevent_t)   items;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    ISC_LINK(dns_dispentry_t)   link;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley};
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#define INVALID_BUCKET      (0xffffdead)
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleytypedef ISC_LIST(dns_dispentry_t)   dns_displist_t;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#define DISPATCHFLAG_CONNECTED      0x00000001U
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystruct dns_dispatch {
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    /* Unlocked. */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    unsigned int        magic;      /* magic */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    dns_dispatchmgr_t      *mgr;        /* dispatch manager */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    isc_task_t         *task;       /* internal task */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    isc_socket_t           *socket;     /* isc socket attached to */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    isc_sockaddr_t      local;      /* local address */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    isc_sockaddr_t      remote;     /* remote address */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    unsigned int        buffersize; /* size of each buffer */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    unsigned int        maxrequests;    /* max requests */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    unsigned int        maxbuffers; /* max buffers */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    /* Locked by mgr->lock. */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    unsigned int        attributes;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    ISC_LINK(dns_dispatch_t) link;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    /* Locked by "lock". */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    isc_mutex_t     lock;       /* locks all below */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    unsigned int        refcount;   /* number of users */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    unsigned int        flags;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    isc_mempool_t          *epool;      /* memory pool for events */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    isc_mempool_t          *bpool;      /* memory pool for buffers */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    isc_mempool_t          *rpool;      /* memory pool request/reply */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    dns_dispatchevent_t    *failsafe_ev;    /* failsafe cancel event */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    unsigned int        recvs;      /* recv() calls outstanding */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    unsigned int        recvs_wanted;   /* recv() calls wanted */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    unsigned int        shutting_down : 1,
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley                shutdown_out : 1;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    isc_result_t        shutdown_why;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    unsigned int        requests;   /* how many requests we have */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    unsigned int        buffers;    /* allocated buffers */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    ISC_LIST(dns_dispentry_t) rq_handlers;  /* request handler list */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    ISC_LIST(dns_dispatchevent_t) rq_events; /* holder for rq events */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    dns_tcpmsg_t        tcpmsg;     /* for tcp streams */
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    dns_dispatchmethods_t   methods;    /* methods to use */
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    isc_lfsr_t      qid_lfsr1;  /* state generator info */
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    isc_lfsr_t      qid_lfsr2;  /* state generator info */
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    unsigned int        qid_nbuckets;   /* hash table size */
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    unsigned int        qid_increment;  /* id increment on collision */
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    dns_displist_t          *qid_table; /* the table itself */
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley};
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#define REQUEST_MAGIC       ISC_MAGIC('D', 'r', 'q', 's')
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#define VALID_REQUEST(e)    ISC_MAGIC_VALID((e), REQUEST_MAGIC)
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#define RESPONSE_MAGIC      ISC_MAGIC('D', 'r', 's', 'p')
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#define VALID_RESPONSE(e)   ISC_MAGIC_VALID((e), RESPONSE_MAGIC)
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#define DISPATCH_MAGIC      ISC_MAGIC('D', 'i', 's', 'p')
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#define VALID_DISPATCH(e)   ISC_MAGIC_VALID((e), DISPATCH_MAGIC)
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#define DNS_DISPATCHMGR_MAGIC   ISC_MAGIC('D', 'M', 'g', 'r')
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#define VALID_DISPATCHMGR(e)    ISC_MAGIC_VALID((e), DNS_DISPATCHMGR_MAGIC)
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley/*
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley * Statics.
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic dns_dispentry_t *bucket_search(dns_dispatch_t *, isc_sockaddr_t *,
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley                      dns_messageid_t, unsigned int);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic void destroy_disp(dns_dispatch_t *);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic void udp_recv(isc_task_t *, isc_event_t *);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic void tcp_recv(isc_task_t *, isc_event_t *);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic inline void startrecv(dns_dispatch_t *);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic isc_uint32_t dns_randomid(dns_dispatch_t *);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic isc_uint32_t dns_hash(dns_dispatch_t *, isc_sockaddr_t *, isc_uint32_t);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic void free_buffer(dns_dispatch_t *disp, void *buf, unsigned int len);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic void *allocate_buffer(dns_dispatch_t *disp, unsigned int len);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic inline void free_event(dns_dispatch_t *disp, dns_dispatchevent_t *ev);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic inline dns_dispatchevent_t *allocate_event(dns_dispatch_t *disp);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic void do_next_request(dns_dispatch_t *disp, dns_dispentry_t *resp);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic void do_next_response(dns_dispatch_t *disp, dns_dispentry_t *resp);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic void do_cancel(dns_dispatch_t *disp, dns_dispentry_t *resp);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic dns_dispentry_t *linear_first(dns_dispatch_t *disp);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic dns_dispentry_t *linear_next(dns_dispatch_t *disp,
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley                    dns_dispentry_t *resp);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley#define LVL(x) \
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    DNS_LOGCATEGORY_DISPATCH, DNS_LOGMODULE_DISPATCH, \
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    ISC_LOG_DEBUG(x)
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic void
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleydispatch_log(dns_dispatch_t *disp,
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley         isc_logcategory_t *category, isc_logmodule_t *module, int level,
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley         const char *fmt, ...)
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley{
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    char msgbuf[2048];
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    va_list ap;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    va_start(ap, fmt);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    vsnprintf(msgbuf, sizeof(msgbuf), fmt, ap);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    va_end(ap);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    isc_log_write(dns_lctx, category, module, level,
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley              "dispatch %p: %s", disp, msgbuf);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley}
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic void
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleyrequest_log(dns_dispatch_t *disp, dns_dispentry_t *resp,
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley        isc_logcategory_t *category, isc_logmodule_t *module, int level,
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley        const char *fmt, ...)
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley{
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    char msgbuf[2048];
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    char peerbuf[256];
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    va_list ap;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    va_start(ap, fmt);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    vsnprintf(msgbuf, sizeof(msgbuf), fmt, ap);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    va_end(ap);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    if (VALID_RESPONSE(resp)) {
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley        isc_sockaddr_format(&resp->host, peerbuf, sizeof peerbuf);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley        isc_log_write(dns_lctx, category, module, level,
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley                  "dispatch %p request %p %s: %s", disp, resp,
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley                  peerbuf, msgbuf);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    } else if (VALID_REQUEST(resp)) {
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley        isc_log_write(dns_lctx, category, module, level,
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley                  "dispatch %p response %p: %s", disp, resp,
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley                  msgbuf);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    } else {
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley        REQUIRE(VALID_REQUEST(resp) || VALID_RESPONSE(resp));
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    }
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley}
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleystatic void
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halleyreseed_lfsr(isc_lfsr_t *lfsr, void *arg)
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley{
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    UNUSED(arg);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    lfsr->count = (random() & 0x1f) + 32;   /* From 32 to 63 states */
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley    lfsr->state = random();
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley}
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley/*
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley * Return an unpredictable message ID.
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley */
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halleystatic isc_uint32_t
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halleydns_randomid(dns_dispatch_t *disp) {
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    isc_uint32_t id;
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    id = isc_lfsr_generate32(&disp->qid_lfsr1, &disp->qid_lfsr2);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    return (id & 0x0000ffffU);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley}
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley/*
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley * Return a hash of the destination and message id.
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley */
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halleystatic isc_uint32_t
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halleydns_hash(dns_dispatch_t *disp, isc_sockaddr_t *dest, isc_uint32_t id) {
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    unsigned int ret;
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    ret = isc_sockaddr_hash(dest, ISC_TRUE);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    ret ^= (id & 0x0000ffff); /* important to mask off garbage bits */
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    ret %= disp->qid_nbuckets;
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    INSIST(ret < disp->qid_nbuckets);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    return (ret);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley}
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halleystatic dns_dispatchmethods_t dns_wire_methods = {
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    dns_randomid,
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    dns_hash
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley};
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halleystatic dns_dispentry_t *
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halleylinear_first(dns_dispatch_t *disp) {
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    dns_dispentry_t *ret;
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    unsigned int bucket;
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    bucket = 0;
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    while (bucket < disp->qid_nbuckets) {
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley        ret = ISC_LIST_HEAD(disp->qid_table[bucket]);
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley        if (ret != NULL)
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley            return (ret);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley        bucket++;
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    }
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    return (NULL);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley}
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halleystatic dns_dispentry_t *
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halleylinear_next(dns_dispatch_t *disp, dns_dispentry_t *resp) {
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    dns_dispentry_t *ret;
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    unsigned int bucket;
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    ret = ISC_LIST_NEXT(resp, link);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    if (ret != NULL)
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley        return (ret);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    bucket = resp->bucket;
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    while (bucket < disp->qid_nbuckets) {
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley        ret = ISC_LIST_HEAD(disp->qid_table[bucket]);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley        if (ret != NULL)
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley            return (ret);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley        bucket++;
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    }
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    return (NULL);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley}
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley/*
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley * Called when refcount reaches 0 (and safe to destroy).
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley *
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley * The dispatch lock must NOT be locked, and the manager lock MUST be
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley * locked.
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley */
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halleystatic void
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halleydestroy_disp(dns_dispatch_t *disp) {
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    dns_dispatchevent_t *ev;
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    dns_dispatchmgr_t *mgr;
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    mgr = disp->mgr;
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    disp->mgr = NULL;
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    ISC_LIST_UNLINK(mgr->list, disp, link);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    disp->magic = 0;
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    dns_tcpmsg_invalidate(&disp->tcpmsg);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    dispatch_log(disp, LVL(90),
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley             "shutting down; detaching from sock %p, task %p",
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley             disp->socket, disp->task);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    /*
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley     * Final cleanup of packets on the request list.
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley     */
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    ev = ISC_LIST_HEAD(disp->rq_events);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    while (ev != NULL) {
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley        ISC_LIST_UNLINK(disp->rq_events, ev, ev_link);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley        free_buffer(disp, ev->buffer.base, ev->buffer.length);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley        free_event(disp, ev);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley        ev = ISC_LIST_HEAD(disp->rq_events);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    }
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    INSIST(disp->buffers == 0);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    INSIST(disp->requests == 0);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    INSIST(disp->recvs == 0);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    isc_socket_detach(&disp->socket);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    isc_task_detach(&disp->task);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    isc_mempool_put(disp->epool, disp->failsafe_ev);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    disp->failsafe_ev = NULL;
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    isc_mempool_destroy(&disp->rpool);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    isc_mempool_destroy(&disp->bpool);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    isc_mempool_destroy(&disp->epool);
948eabe2a254a8a278ef6325f3790e75329ee656Bob Halley    isc_mem_put(mgr->mctx, disp->qid_table,
4e142a5bccd2944174ad9ae58d86cf03e170054dBob Halley            disp->qid_nbuckets * sizeof(dns_displist_t));

    isc_mem_put(mgr->mctx, disp, sizeof(dns_dispatch_t));
}


static dns_dispentry_t *
bucket_search(dns_dispatch_t *disp, isc_sockaddr_t *dest, dns_messageid_t id,
          unsigned int bucket)
{
    dns_dispentry_t *res;

    REQUIRE(bucket < disp->qid_nbuckets);

    res = ISC_LIST_HEAD(disp->qid_table[bucket]);

    while (res != NULL) {
        if ((res->id == id) && isc_sockaddr_equal(dest, &res->host))
            return (res);
        res = ISC_LIST_NEXT(res, link);
    }

    return (NULL);
}

static void
free_buffer(dns_dispatch_t *disp, void *buf, unsigned int len) {
    isc_sockettype_t socktype;

    INSIST(buf != NULL && len != 0);
    INSIST(disp->buffers > 0);
    disp->buffers--;

    socktype = isc_socket_gettype(disp->socket);

    switch (socktype) {
    case isc_sockettype_tcp:
        isc_mem_put(disp->mgr->mctx, buf, len);
        break;
    case isc_sockettype_udp:
        if (len == disp->buffersize)
            isc_mempool_put(disp->bpool, buf);
        else
            isc_mem_put(disp->mgr->mctx, buf, len);
        break;
    default:
        INSIST(0);
        break;
    }
}

static void *
allocate_buffer(dns_dispatch_t *disp, unsigned int len) {
    void *temp;

    INSIST(len > 0);

    if (len == disp->buffersize)
        temp = isc_mempool_get(disp->bpool);
    else
        temp = isc_mem_get(disp->mgr->mctx, len);

    if (temp != NULL)
        disp->buffers++;

    return (temp);
}

static inline void
free_event(dns_dispatch_t *disp, dns_dispatchevent_t *ev) {
    if (disp->failsafe_ev == ev) {
        INSIST(disp->shutdown_out == 1);
        disp->shutdown_out = 0;

        return;
    }

    isc_mempool_put(disp->epool, ev);
}

static inline dns_dispatchevent_t *
allocate_event(dns_dispatch_t *disp) {
    dns_dispatchevent_t *ev;

    ev = isc_mempool_get(disp->epool);

    return (ev);
}

/*
 * General flow:
 *
 * If I/O result == CANCELED, free the buffer and notify everyone as
 * the various queues drain.
 *
 * If I/O is error (not canceled and not success) log it, free the buffer,
 * and restart.
 *
 * If query:
 *  if no listeners: free the buffer, restart.
 *  if listener: allocate event, fill in details.
 *      If cannot allocate, free buffer, restart.
 *  if rq event queue is not empty, queue.  else, send.
 *  restart.
 *
 * If response:
 *  Allocate event, fill in details.
 *      If cannot allocate, free buffer, restart.
 *  find target.  If not found, free buffer, restart.
 *  if event queue is not empty, queue.  else, send.
 *  restart.
 */
static void
udp_recv(isc_task_t *task, isc_event_t *ev_in) {
    isc_socketevent_t *ev = (isc_socketevent_t *)ev_in;
    dns_dispatch_t *disp = ev_in->ev_arg;
    dns_messageid_t id;
    isc_result_t dres;
    isc_buffer_t source;
    unsigned int flags;
    dns_dispentry_t *resp;
    dns_dispatchevent_t *rev;
    unsigned int bucket;
    isc_boolean_t killit;
    isc_boolean_t queue_request;
    isc_boolean_t queue_response;

    UNUSED(task);

    LOCK(&disp->lock);

    dispatch_log(disp, LVL(90),
             "Got packet: requests %d, buffers %d, recvs %d",
             disp->requests, disp->buffers, disp->recvs);

    INSIST(disp->recvs > 0);
    disp->recvs--;

    if (disp->refcount == 0) {
        /*
         * This dispatcher is shutting down.
         */
        free_buffer(disp, ev->region.base, ev->region.length);

        killit = ISC_FALSE;
        if (disp->recvs == 0 && disp->refcount == 0)
            killit = ISC_TRUE;

        UNLOCK(&disp->lock);

        if (killit)
            destroy_disp(disp);

        isc_event_free(&ev_in);
        return;
    }

    if (ev->result != ISC_R_SUCCESS) {
        free_buffer(disp, ev->region.base, ev->region.length);

        /*
         * If the recv() was canceled pass the word on.
         */
        if (ev->result == ISC_R_CANCELED) {
            UNLOCK(&disp->lock);
            isc_event_free(&ev_in);
            return;
        }

        /*
         * otherwise, on strange error, log it and restart.
         * XXXMLG
         */
        goto restart;
    }

    /*
     * Peek into the buffer to see what we can see.
     */
    isc_buffer_init(&source, ev->region.base, ev->region.length);
    isc_buffer_add(&source, ev->n);
    dres = dns_message_peekheader(&source, &id, &flags);
    if (dres != ISC_R_SUCCESS) {
        free_buffer(disp, ev->region.base, ev->region.length);
        dispatch_log(disp, LVL(10), "Got garbage packet");
        goto restart;
    }

    dispatch_log(disp, LVL(92),
             "Got valid DNS message header, /QR %c, id %u",
             ((flags & DNS_MESSAGEFLAG_QR) ? '1' : '0'), id);

    /*
     * Look at flags.  If query, check to see if we have someone handling
     * them.  If response, look to see where it goes.
     */
    queue_request = ISC_FALSE;
    queue_response = ISC_FALSE;
    if ((flags & DNS_MESSAGEFLAG_QR) == 0) {
        resp = ISC_LIST_HEAD(disp->rq_handlers);
        while (resp != NULL) {
            if (resp->item_out == ISC_FALSE)
                break;
            resp = ISC_LIST_NEXT(resp, link);
        }
        if (resp == NULL)
            queue_request = ISC_TRUE;
        rev = allocate_event(disp);
        if (rev == NULL) {
            free_buffer(disp, ev->region.base, ev->region.length);
            goto restart;
        }
        /* query */
    } else {
        /* response */
        bucket = disp->methods.hash(disp, &ev->address, id);
        resp = bucket_search(disp, &ev->address, id, bucket);
        dispatch_log(disp, LVL(90),
                 "Search for response in bucket %d: %s",
                 bucket, (resp == NULL ? "NOT FOUND" : "FOUND"));

        if (resp == NULL) {
            free_buffer(disp, ev->region.base, ev->region.length);
            goto restart;
        }
        queue_response = resp->item_out;
        rev = allocate_event(disp);
        if (rev == NULL) {
            free_buffer(disp, ev->region.base, ev->region.length);
            goto restart;
        }
    }

    /*
     * At this point, rev contains the event we want to fill in, and
     * resp contains the information on the place to send it to.
     * Send the event off.
     */
    isc_buffer_init(&rev->buffer, ev->region.base, ev->region.length);
    isc_buffer_add(&rev->buffer, ev->n);
    rev->result = ISC_R_SUCCESS;
    rev->id = id;
    rev->addr = ev->address;
    rev->pktinfo = ev->pktinfo;
    rev->attributes = ev->attributes;
    if (queue_request) {
        ISC_LIST_APPEND(disp->rq_events, rev, ev_link);
    } else if (queue_response) {
        ISC_LIST_APPEND(resp->items, rev, ev_link);
    } else {
        ISC_EVENT_INIT(rev, sizeof(*rev), 0, NULL,
                   DNS_EVENT_DISPATCH,
                   resp->action, resp->arg, resp, NULL, NULL);
        request_log(disp, resp, LVL(90),
                "[a] Sent event %p buffer %p len %d to task %p",
                rev, rev->buffer.base, rev->buffer.length,
                resp->task);
        resp->item_out = ISC_TRUE;
        isc_task_send(resp->task, (isc_event_t **)&rev);
    }

    /*
     * Restart recv() to get the next packet.
     */
 restart:
    startrecv(disp);

    UNLOCK(&disp->lock);

    isc_event_free(&ev_in);
}

/*
 * General flow:
 *
 * If I/O result == CANCELED, free the buffer and notify everyone as
 * the various queues drain.
 *
 * If I/O is error (not canceled and not success) log it, free the buffer,
 * and restart.
 *
 * If query:
 *  if no listeners: free the buffer, restart.
 *  if listener: allocate event, fill in details.
 *      If cannot allocate, free buffer, restart.
 *  if rq event queue is not empty, queue.  else, send.
 *  restart.
 *
 * If response:
 *  Allocate event, fill in details.
 *      If cannot allocate, free buffer, restart.
 *  find target.  If not found, free buffer, restart.
 *  if event queue is not empty, queue.  else, send.
 *  restart.
 */
static void
tcp_recv(isc_task_t *task, isc_event_t *ev_in) {
    dns_dispatch_t *disp = ev_in->ev_arg;
    dns_tcpmsg_t *tcpmsg = &disp->tcpmsg;
    dns_messageid_t id;
    isc_result_t dres;
    unsigned int flags;
    dns_dispentry_t *resp;
    dns_dispatchevent_t *rev;
    unsigned int bucket;
    isc_boolean_t killit;
    isc_boolean_t queue_request;
    isc_boolean_t queue_response;

    UNUSED(task);

    REQUIRE(VALID_DISPATCH(disp));

    dispatch_log(disp, LVL(90),
             "Got TCP packet: requests %d, buffers %d, recvs %d",
             disp->requests, disp->buffers, disp->recvs);

    LOCK(&disp->lock);

    INSIST(disp->recvs > 0);
    disp->recvs--;

    if (disp->refcount == 0) {
        /*
         * This dispatcher is shutting down.  Force cancelation.
         */
        tcpmsg->result = ISC_R_CANCELED;
    }

    switch (tcpmsg->result) {
    case ISC_R_SUCCESS:
        break;

    case ISC_R_EOF:
        dispatch_log(disp, LVL(90), "Shutting down on EOF");
        disp->shutdown_why = ISC_R_EOF;
        disp->shutting_down = 1;
        do_cancel(disp, NULL);
        /* FALLTHROUGH */

    case ISC_R_CANCELED:
        /*
         * If the recv() was canceled pass the word on.
         */
        killit = ISC_FALSE;
        if (disp->recvs == 0 && disp->refcount == 0)
            killit = ISC_TRUE;

        UNLOCK(&disp->lock);

        /*
         * The event is statically allocated in the tcpmsg
         * structure, and destroy_disp() frees the tcpmsg, so we must
         * free the event *before* calling destroy_disp().
         */
        isc_event_free(&ev_in);

        if (killit)
            destroy_disp(disp);

        return;

    default:
        /*
         * otherwise, on strange error, log it and restart.
         * XXXMLG
         */
        goto restart;
    }

    dispatch_log(disp, LVL(90), "result %d, length == %d, addr = %p",
             tcpmsg->result,
             tcpmsg->buffer.length, tcpmsg->buffer.base);

    /*
     * Peek into the buffer to see what we can see.
     */
    dres = dns_message_peekheader(&tcpmsg->buffer, &id, &flags);
    if (dres != ISC_R_SUCCESS) {
        dispatch_log(disp, LVL(10), "Got garbage packet");
        goto restart;
    }

    dispatch_log(disp, LVL(92),
             "Got valid DNS message header, /QR %c, id %u",
             ((flags & DNS_MESSAGEFLAG_QR) ? '1' : '0'), id);

    /*
     * Allocate an event to send to the query or response client, and
     * allocate a new buffer for our use.
     */

    /*
     * Look at flags.  If query, check to see if we have someone handling
     * them.  If response, look to see where it goes.
     */
    queue_request = ISC_FALSE;
    queue_response = ISC_FALSE;
    if ((flags & DNS_MESSAGEFLAG_QR) == 0) {
        resp = ISC_LIST_HEAD(disp->rq_handlers);
        while (resp != NULL) {
            if (resp->item_out == ISC_FALSE)
                break;
            resp = ISC_LIST_NEXT(resp, link);
        }
        if (resp == NULL)
            queue_request = ISC_TRUE;
        rev = allocate_event(disp);
        if (rev == NULL)
            goto restart;
        /* query */
    } else {
        /* response */
        bucket = disp->methods.hash(disp, &tcpmsg->address, id);
        resp = bucket_search(disp, &tcpmsg->address, id, bucket);
        dispatch_log(disp, LVL(90),
                 "Search for response in bucket %d: %s",
                 bucket, (resp == NULL ? "NOT FOUND" : "FOUND"));

        if (resp == NULL)
            goto restart;
        queue_response = resp->item_out;
        rev = allocate_event(disp);
        if (rev == NULL)
            goto restart;
    }

    /*
     * At this point, rev contains the event we want to fill in, and
     * resp contains the information on the place to send it to.
     * Send the event off.
     */
    dns_tcpmsg_keepbuffer(tcpmsg, &rev->buffer);
    disp->buffers++;
    rev->result = ISC_R_SUCCESS;
    rev->id = id;
    rev->addr = tcpmsg->address;
    if (queue_request) {
        ISC_LIST_APPEND(disp->rq_events, rev, ev_link);
    } else if (queue_response) {
        ISC_LIST_APPEND(resp->items, rev, ev_link);
    } else {
        ISC_EVENT_INIT(rev, sizeof(*rev), 0, NULL, DNS_EVENT_DISPATCH,
                   resp->action, resp->arg, resp, NULL, NULL);
        request_log(disp, resp, LVL(90),
                "[b] Sent event %p buffer %p len %d to task %p",
                rev, rev->buffer.base, rev->buffer.length,
                resp->task);
        resp->item_out = ISC_TRUE;
        isc_task_send(resp->task, (isc_event_t **)&rev);
    }

    /*
     * Restart recv() to get the next packet.
     */
 restart:
    startrecv(disp);

    UNLOCK(&disp->lock);

    isc_event_free(&ev_in);
}

/*
 * disp must be locked.
 */
static void
startrecv(dns_dispatch_t *disp) {
    isc_sockettype_t socktype;
    isc_result_t res;
    isc_region_t region;
    unsigned int wanted;

    if (disp->shutting_down == 1)
        return;

    wanted = ISC_MIN(disp->recvs_wanted, disp->requests + 2);
    if (wanted == 0)
        return;

    if (disp->recvs >= wanted)
        return;

    if (disp->buffers >= disp->maxbuffers)
        return;

    socktype = isc_socket_gettype(disp->socket);

    while (disp->recvs < wanted) {
        switch (socktype) {
            /*
             * UDP reads are always maximal.
             */
        case isc_sockettype_udp:
            region.length = disp->buffersize;
            region.base = allocate_buffer(disp, disp->buffersize);
            if (region.base == NULL)
                return;
            res = isc_socket_recv(disp->socket, &region, 1,
                          disp->task, udp_recv, disp);
            if (res != ISC_R_SUCCESS) {
                disp->shutdown_why = res;
                disp->shutting_down = 1;
                do_cancel(disp, NULL);
                return;
            }
            disp->recvs++;
            break;

        case isc_sockettype_tcp:
            res = dns_tcpmsg_readmessage(&disp->tcpmsg,
                             disp->task, tcp_recv,
                             disp);
            if (res != ISC_R_SUCCESS) {
                disp->shutdown_why = res;
                disp->shutting_down = 1;
                do_cancel(disp, NULL);
                return;
            }
            disp->recvs++;
            break;
        }
    }
}

/*
 * Mgr must be locked when calling this function.
 */
static isc_boolean_t
destroy_mgr_ok(dns_dispatchmgr_t *mgr) {
    if (!MGR_IS_SHUTTINGDOWN(mgr))
        return (ISC_FALSE);
    if (!ISC_LIST_EMPTY(mgr->list))
        return (ISC_FALSE);

    return (ISC_TRUE);
}

/*
 * Mgr must be unlocked when calling this function.
 */
static void
destroy_mgr(dns_dispatchmgr_t **mgrp) {
    isc_mem_t *mctx;
    dns_dispatchmgr_t *mgr;

    mgr = *mgrp;
    *mgrp = NULL;

    mctx = mgr->mctx;

    mgr->magic = 0;
    mgr->mctx = 0;
    isc_mutex_destroy(&mgr->lock);
    mgr->state = 0;

    isc_mem_put(mctx, mgr, sizeof(dns_dispatchmgr_t));
    isc_mem_detach(&mctx);
}

/*
 * Publics.
 */

isc_result_t
dns_dispatchmgr_create(isc_mem_t *mctx, dns_dispatchmgr_t **mgrp) {
    dns_dispatchmgr_t *mgr;
    isc_result_t result;

    REQUIRE(mctx != NULL);
    REQUIRE(mgrp != NULL && *mgrp == NULL);

    mgr = isc_mem_get(mctx, sizeof(dns_dispatchmgr_t));
    if (mgr == NULL)
        return (ISC_R_NOMEMORY);

    result = isc_mutex_init(&mgr->lock);
    if (result != ISC_R_SUCCESS) {
        isc_mem_put(mctx, mgr, sizeof(dns_dispatchmgr_t));
        return (result);
    }

    mgr->magic = DNS_DISPATCHMGR_MAGIC;
    mgr->state = 0;
    mgr->mctx = NULL;
    isc_mem_attach(mctx, &mgr->mctx);
    ISC_LIST_INIT(mgr->list);

    *mgrp = mgr;
    return (ISC_R_SUCCESS);
}


void
dns_dispatchmgr_destroy(dns_dispatchmgr_t **mgrp) {
    dns_dispatchmgr_t *mgr;
    isc_boolean_t killit;

    REQUIRE(mgrp != NULL);
    REQUIRE(VALID_DISPATCHMGR(*mgrp));

    mgr = *mgrp;
    *mgrp = NULL;

    LOCK(&mgr->lock);
    mgr->state |= MGR_SHUTTINGDOWN;
    killit = destroy_mgr_ok(mgr);
    UNLOCK(&mgr->lock);

    if (killit)
        destroy_mgr(&mgr);
}


#define ATTRMATCH(_a1, _a2, _mask) (((_a1) & (_mask)) == ((_a2) & (_mask)))

static isc_boolean_t
local_addr_match(dns_dispatch_t *disp, isc_sockaddr_t *addr) {
    in_port_t port;

    if (addr == NULL)
        return (ISC_TRUE);

    port = isc_sockaddr_getport(addr);
    if (port == 0)
        return (isc_sockaddr_eqaddr(&disp->local, addr));
    else
        return (isc_sockaddr_equal(&disp->local, addr));
}

static isc_boolean_t
remote_addr_match(dns_dispatch_t *disp, isc_sockaddr_t *addr) {
    if (addr == NULL)
        return (ISC_TRUE);

    if ((disp->flags & DISPATCHFLAG_CONNECTED) == 0)
        return (ISC_TRUE);

    return (isc_sockaddr_equal(&disp->remote, addr));
}

isc_result_t
dns_dispatchmgr_find(dns_dispatchmgr_t *mgr,
             isc_sockaddr_t *local, isc_sockaddr_t *remote,
             unsigned int attributes, unsigned int mask,
             dns_dispatch_t **dispp)
{
    dns_dispatch_t *disp;
    isc_result_t result;

    REQUIRE(VALID_DISPATCHMGR(mgr));
    REQUIRE(dispp != NULL && *dispp == NULL);

    LOCK(&mgr->lock);
    disp = ISC_LIST_HEAD(mgr->list);
    while (disp != NULL) {
        if (!IS_PRIVATE(disp)
            && ATTRMATCH(disp->attributes, attributes, mask)
            && local_addr_match(disp, local)
            && remote_addr_match(disp, remote))
            break;
        disp = ISC_LIST_NEXT(disp, link);
    }

    if (disp == NULL) {
        result = ISC_R_NOTFOUND;
        goto out;
    }

    dns_dispatch_attach(disp, dispp);

    result = ISC_R_SUCCESS;

 out:
    UNLOCK(&mgr->lock);

    return (result);
}


isc_result_t
dns_dispatch_create(dns_dispatchmgr_t *mgr, isc_socket_t *sock,
            isc_task_t *task, unsigned int maxbuffersize,
            unsigned int maxbuffers, unsigned int maxrequests,
            unsigned int buckets, unsigned int increment,
            dns_dispatchmethods_t *methods, unsigned int attributes,
            dns_dispatch_t **dispp)
{
    dns_dispatch_t *disp;
    isc_result_t res;
    isc_sockettype_t socktype;
    unsigned int i;
    isc_sockaddr_t local;

    REQUIRE(VALID_DISPATCHMGR(mgr));
    REQUIRE(sock != NULL);
    REQUIRE(task != NULL);
    REQUIRE(buckets < 2097169);  /* next prime > 65536 * 32 */
    REQUIRE(increment > buckets);
    REQUIRE(maxbuffersize >= 512 && maxbuffersize < (64 * 1024));
    REQUIRE(maxbuffers > 0);
    REQUIRE(dispp != NULL && *dispp == NULL);

    socktype = isc_socket_gettype(sock);
    REQUIRE(socktype == isc_sockettype_udp ||
        socktype == isc_sockettype_tcp);

    memset(&local, 0, sizeof local);
    res = isc_socket_getsockname(sock, &local);
    if (res != ISC_R_SUCCESS)
        return (res);

    disp = isc_mem_get(mgr->mctx, sizeof(dns_dispatch_t));
    if (disp == NULL)
        return (ISC_R_NOMEMORY);

    disp->magic = 0;
    disp->buffersize = maxbuffersize;
    disp->maxrequests = maxrequests;
    disp->maxbuffers = maxbuffers;
    disp->attributes = attributes;
    ISC_LINK_INIT(disp, link);
    disp->refcount = 1;
    disp->recvs = 0;
    if (socktype == isc_sockettype_udp) {
        disp->recvs_wanted = 4; /* XXXMLG config option */
    } else {
        disp->recvs_wanted = 1;
    }
    memset(&disp->remote, 0, sizeof disp->remote);
    res = isc_socket_getpeername(sock, &disp->remote);
    if (res == ISC_R_SUCCESS)
        disp->flags = DISPATCHFLAG_CONNECTED;
    disp->local = local;
    disp->shutting_down = 0;
    disp->shutdown_out = 0;
    disp->shutdown_why = ISC_R_UNEXPECTED;
    disp->requests = 0;
    disp->buffers = 0;
    ISC_LIST_INIT(disp->rq_handlers);
    ISC_LIST_INIT(disp->rq_events);

    if (methods == NULL)
        disp->methods = dns_wire_methods;
    else
        disp->methods = *methods;

    disp->qid_table = isc_mem_get(mgr->mctx,
                      buckets * sizeof(dns_displist_t));
    if (disp->qid_table == NULL) {
        res = ISC_R_NOMEMORY;
        goto out1;
    }

    for (i = 0 ; i < buckets ; i++)
        ISC_LIST_INIT(disp->qid_table[i]);

    disp->qid_nbuckets = buckets;
    disp->qid_increment = increment;

    if (isc_mutex_init(&disp->lock) != ISC_R_SUCCESS) {
        res = ISC_R_UNEXPECTED;
        UNEXPECTED_ERROR(__FILE__, __LINE__, "isc_mutex_init failed");
        goto out2;
    }

    disp->epool = NULL;
    if (isc_mempool_create(mgr->mctx, sizeof(dns_dispatchevent_t),
                   &disp->epool) != ISC_R_SUCCESS) {
        res = ISC_R_NOMEMORY;
        goto out3;
    }
    isc_mempool_setname(disp->epool, "disp_epool");

    disp->bpool = NULL;
    if (isc_mempool_create(mgr->mctx, maxbuffersize,
                   &disp->bpool) != ISC_R_SUCCESS) {
        res = ISC_R_NOMEMORY;
        goto out4;
    }
    isc_mempool_setmaxalloc(disp->bpool, maxbuffers);
    isc_mempool_setname(disp->bpool, "disp_bpool");

    disp->rpool = NULL;
    if (isc_mempool_create(mgr->mctx, sizeof(dns_dispentry_t),
                   &disp->rpool) != ISC_R_SUCCESS) {
        res = ISC_R_NOMEMORY;
        goto out5;
    }
    isc_mempool_setname(disp->rpool, "disp_rpool");

    /*
     * Keep some number of items around.  This should be a config
     * option.  For now, keep 8, but later keep at least two even
     * if the caller wants less.  This allows us to ensure certain
     * things, like an event can be "freed" and the next allocation
     * will always succeed.
     *
     * Note that if limits are placed on anything here, we use one
     * event internally, so the actual limit should be "wanted + 1."
     *
     * XXXMLG
     */
    isc_mempool_setfreemax(disp->epool, 8);
    isc_mempool_setfreemax(disp->bpool, 8);
    isc_mempool_setfreemax(disp->rpool, 8);

    disp->failsafe_ev = allocate_event(disp);
    if (disp->failsafe_ev == NULL) {
        res = ISC_R_NOMEMORY;
        goto out6;
    }

    /*
     * Initialize to a 32-bit LFSR.  Both of these are from Applied
     * Cryptography.
     *
     * lfsr1:
     *  x^32 + x^7 + x^5 + x^3 + x^2 + x + 1
     *
     * lfsr2:
     *  x^32 + x^7 + x^6 + x^2 + 1
     */
    isc_lfsr_init(&disp->qid_lfsr1, 0, 32, 0x80000057U,
              0, reseed_lfsr, disp);
    isc_lfsr_init(&disp->qid_lfsr2, 0, 32, 0x800000c2U,
              0, reseed_lfsr, disp);

    disp->magic = DISPATCH_MAGIC;
    disp->mgr = mgr;

    disp->task = NULL;
    isc_task_attach(task, &disp->task);
    dispatch_log(disp, LVL(90), "attaching to task %p", disp->task);
    disp->socket = NULL;
    isc_socket_attach(sock, &disp->socket);
    dispatch_log(disp, LVL(90), "attaching to socket %p", disp->socket);

    dns_tcpmsg_init(mgr->mctx, disp->socket, &disp->tcpmsg);

    /*
     * Append it to the dispatcher list.
     */
    LOCK(&mgr->lock);
    ISC_LIST_APPEND(mgr->list, disp, link);
    UNLOCK(&mgr->lock);

    *dispp = disp;

    return (ISC_R_SUCCESS);

    /*
     * error returns
     */
 out6:
    isc_mempool_destroy(&disp->rpool);
 out5:
    isc_mempool_destroy(&disp->bpool);
 out4:
    isc_mempool_destroy(&disp->epool);
 out3:
    isc_mutex_destroy(&disp->lock);
 out2:
    isc_mem_put(mgr->mctx, disp->mgr->mctx,
            disp->qid_nbuckets * sizeof(void *));
 out1:
    isc_mem_put(mgr->mctx, disp, sizeof(dns_dispatch_t));

    return (res);
}

void
dns_dispatch_attach(dns_dispatch_t *disp, dns_dispatch_t **dispp) {
    REQUIRE(VALID_DISPATCH(disp));
    REQUIRE(dispp != NULL && *dispp == NULL);

    LOCK(&disp->lock);
    disp->refcount++;
    UNLOCK(&disp->lock);

    *dispp = disp;
}

void
dns_dispatch_detach(dns_dispatch_t **dispp) {
    dns_dispatch_t *disp;
    isc_boolean_t killit;
    dns_dispatchmgr_t *mgr;

    REQUIRE(dispp != NULL && VALID_DISPATCH(*dispp));

    disp = *dispp;
    *dispp = NULL;

    mgr = disp->mgr;

    LOCK(&mgr->lock);
    LOCK(&disp->lock);

    INSIST(disp->refcount > 0);
    disp->refcount--;
    killit = ISC_FALSE;
    if (disp->refcount == 0) {
        if (disp->recvs > 0)
            isc_socket_cancel(disp->socket, NULL,
                      ISC_SOCKCANCEL_RECV);
        else
            killit = ISC_TRUE;
    }

    dispatch_log(disp, LVL(90), "detach: refcount %d", disp->refcount);

    UNLOCK(&disp->lock);

    if (killit)
        destroy_disp(disp);

    killit = destroy_mgr_ok(mgr);

    UNLOCK(&mgr->lock);

    if (killit)
        destroy_mgr(&mgr);
}

isc_result_t
dns_dispatch_addresponse(dns_dispatch_t *disp, isc_sockaddr_t *dest,
             isc_task_t *task, isc_taskaction_t action, void *arg,
             dns_messageid_t *idp, dns_dispentry_t **resp)
{
    dns_dispentry_t *res;
    unsigned int bucket;
    dns_messageid_t id;
    int i;
    isc_boolean_t ok;

    REQUIRE(VALID_DISPATCH(disp));
    REQUIRE(task != NULL);
    REQUIRE(dest != NULL);
    REQUIRE(resp != NULL && *resp == NULL);
    REQUIRE(idp != NULL);

    LOCK(&disp->lock);

    if (disp->shutting_down == 1) {
        UNLOCK(&disp->lock);
        return (ISC_R_SHUTTINGDOWN);
    }

    if (disp->requests == disp->maxrequests) {
        UNLOCK(&disp->lock);
        return (ISC_R_QUOTA);
    }

    /*
     * Try somewhat hard to find an unique ID.
     */
    id = disp->methods.randomid(disp);
    bucket = disp->methods.hash(disp, dest, id);
    ok = ISC_FALSE;
    for (i = 0 ; i < 64 ; i++) {
        if (bucket_search(disp, dest, id, bucket) == NULL) {
            ok = ISC_TRUE;
            break;
        }
        id += disp->qid_increment;
        id &= 0x0000ffff;
        bucket = disp->methods.hash(disp, dest, id);
    }

    if (!ok) {
        UNLOCK(&disp->lock);
        return (ISC_R_NOMORE);
    }

    res = isc_mempool_get(disp->rpool);
    if (res == NULL) {
        UNLOCK(&disp->lock);
        return (ISC_R_NOMEMORY);
    }

    disp->refcount++;
    disp->requests++;
    res->task = NULL;
    isc_task_attach(task, &res->task);
    res->magic = RESPONSE_MAGIC;
    res->id = id;
    res->bucket = bucket;
    res->host = *dest;
    res->action = action;
    res->arg = arg;
    res->item_out = ISC_FALSE;
    ISC_LIST_INIT(res->items);
    ISC_LINK_INIT(res, link);
    ISC_LIST_APPEND(disp->qid_table[bucket], res, link);

    request_log(disp, res, LVL(90),
            "attached to task %p", res->task);

    startrecv(disp);

    UNLOCK(&disp->lock);

    *idp = id;
    *resp = res;

    return (ISC_R_SUCCESS);
}

void
dns_dispatch_removeresponse(dns_dispatch_t *disp, dns_dispentry_t **resp,
                dns_dispatchevent_t **sockevent)
{
    dns_dispentry_t *res;
    dns_dispatchevent_t *ev;
    unsigned int bucket;
    isc_boolean_t killit;
    unsigned int n;
    isc_eventlist_t events;

    REQUIRE(VALID_DISPATCH(disp));
    REQUIRE(resp != NULL);
    REQUIRE(VALID_RESPONSE(*resp));

    res = *resp;
    *resp = NULL;

    if (sockevent != NULL) {
        REQUIRE(*sockevent != NULL);
        ev = *sockevent;
        *sockevent = NULL;
    } else {
        ev = NULL;
    }

    LOCK(&disp->lock);

    INSIST(disp->requests > 0);
    disp->requests--;
    INSIST(disp->refcount > 0);
    disp->refcount--;
    killit = ISC_FALSE;
    if (disp->refcount == 0) {
        if (disp->recvs > 0)
            isc_socket_cancel(disp->socket, NULL,
                      ISC_SOCKCANCEL_RECV);
        else
            killit = ISC_TRUE;
    }

    bucket = res->bucket;

    ISC_LIST_UNLINK(disp->qid_table[bucket], res, link);

    if (ev == NULL && res->item_out) {
        /*
         * We've posted our event, but the caller hasn't gotten it
         * yet.  Take it back.
         */
        ISC_LIST_INIT(events);
        n = isc_task_unsend(res->task, res, DNS_EVENT_DISPATCH,
                    NULL, &events);
        /*
         * We had better have gotten it back.
         */
        INSIST(n == 1);
        ev = (dns_dispatchevent_t *)ISC_LIST_HEAD(events);
    }

    if (ev != NULL) {
        REQUIRE(res->item_out == ISC_TRUE);
        res->item_out = ISC_FALSE;
        if (ev->buffer.base != NULL)
            free_buffer(disp, ev->buffer.base, ev->buffer.length);
        free_event(disp, ev);
    }

    request_log(disp, res, LVL(90), "detaching from task %p", res->task);
    isc_task_detach(&res->task);

    /*
     * Free any buffered requests as well
     */
    ev = ISC_LIST_HEAD(res->items);
    while (ev != NULL) {
        ISC_LIST_UNLINK(res->items, ev, ev_link);
        if (ev->buffer.base != NULL)
            free_buffer(disp, ev->buffer.base, ev->buffer.length);
        free_event(disp, ev);
        ev = ISC_LIST_HEAD(res->items);
    }
    res->magic = 0;
    isc_mempool_put(disp->rpool, res);
    if (disp->shutting_down == 1)
        do_cancel(disp, NULL);
    else
        startrecv(disp);

    UNLOCK(&disp->lock);

    if (killit)
        destroy_disp(disp);
}

isc_result_t
dns_dispatch_addrequest(dns_dispatch_t *disp,
            isc_task_t *task, isc_taskaction_t action, void *arg,
            dns_dispentry_t **resp)
{
    dns_dispentry_t *res;

    REQUIRE(VALID_DISPATCH(disp));
    REQUIRE(task != NULL);
    REQUIRE(resp != NULL && *resp == NULL);

    LOCK(&disp->lock);

    if (disp->shutting_down == 1) {
        UNLOCK(&disp->lock);
        return (ISC_R_SHUTTINGDOWN);
    }

    if (disp->requests == disp->maxrequests) {
        UNLOCK(&disp->lock);
        return (ISC_R_QUOTA);
    }

    res = isc_mempool_get(disp->rpool);
    if (res == NULL) {
        UNLOCK(&disp->lock);
        return (ISC_R_NOMEMORY);
    }

    disp->refcount++;
    disp->requests++;
    res->task = NULL;
    isc_task_attach(task, &res->task);

    res->magic = REQUEST_MAGIC;
    res->bucket = INVALID_BUCKET;
    res->action = action;
    res->arg = arg;
    res->item_out = ISC_FALSE;
    ISC_LIST_INIT(res->items);
    ISC_LINK_INIT(res, link);
    ISC_LIST_APPEND(disp->rq_handlers, res, link);

    request_log(disp, res, LVL(90), "attaching task %p", res->task);

    /*
     * If there are queries waiting to be processed, give this critter
     * one of them.
     */
    do_next_request(disp, res);

    startrecv(disp);

    UNLOCK(&disp->lock);

    *resp = res;

    return (ISC_R_SUCCESS);
}

void
dns_dispatch_removerequest(dns_dispatch_t *disp, dns_dispentry_t **resp,
               dns_dispatchevent_t **sockevent)
{
    dns_dispentry_t *res;
    dns_dispatchevent_t *ev;
    isc_boolean_t killit;
    unsigned int n;
    isc_eventlist_t events;

    REQUIRE(VALID_DISPATCH(disp));
    REQUIRE(resp != NULL);
    REQUIRE(VALID_REQUEST(*resp));

    res = *resp;
    *resp = NULL;

    if (sockevent != NULL) {
        REQUIRE(*sockevent != NULL);
        ev = *sockevent;
        *sockevent = NULL;
    } else {
        ev = NULL;
    }

    LOCK(&disp->lock);

    INSIST(disp->requests > 0);
    disp->requests--;
    INSIST(disp->refcount > 0);
    disp->refcount--;
    killit = ISC_FALSE;
    if (disp->refcount == 0) {
        if (disp->recvs > 0)
            isc_socket_cancel(disp->socket, NULL,
                      ISC_SOCKCANCEL_RECV);
        else
            killit = ISC_TRUE;
    }

    ISC_LIST_UNLINK(disp->rq_handlers, res, link);

    if (ev == NULL && res->item_out) {
        /*
         * We've posted our event, but the caller hasn't gotten it
         * yet.  Take it back.
         */
        ISC_LIST_INIT(events);
        n = isc_task_unsend(res->task, res, DNS_EVENT_DISPATCH,
                    NULL, &events);
        /*
         * We had better have gotten it back.
         */
        INSIST(n == 1);
        ev = (dns_dispatchevent_t *)ISC_LIST_HEAD(events);
    }

    if (ev != NULL) {
        REQUIRE(res->item_out == ISC_TRUE);
        res->item_out = ISC_FALSE;
        if (ev->buffer.base != NULL)
            free_buffer(disp, ev->buffer.base, ev->buffer.length);
        free_event(disp, ev);
    }

    request_log(disp, res, LVL(90), "detaching from task %p", res->task);
    isc_task_detach(&res->task);

    res->magic = 0;
    isc_mempool_put(disp->rpool, res);
    if (disp->shutting_down == 1)
        do_cancel(disp, NULL);
    else
        startrecv(disp);

    UNLOCK(&disp->lock);

    if (killit)
        destroy_disp(disp);
}

void
dns_dispatch_freeevent(dns_dispatch_t *disp, dns_dispentry_t *resp,
               dns_dispatchevent_t **sockevent)
{
    dns_dispatchevent_t *ev;
    isc_boolean_t response;

    REQUIRE(VALID_DISPATCH(disp));
    REQUIRE(sockevent != NULL && *sockevent != NULL);

    ev = *sockevent;
    *sockevent = NULL;

    response = ISC_FALSE;
    if (VALID_RESPONSE(resp)) {
        response = ISC_TRUE;
    } else {
        REQUIRE(VALID_RESPONSE(resp) || VALID_REQUEST(resp));
    }

    LOCK(&disp->lock);
    REQUIRE(ev != disp->failsafe_ev);
    REQUIRE(resp->item_out == ISC_TRUE);
    REQUIRE(ev->result == ISC_R_SUCCESS);
    resp->item_out = ISC_FALSE;

    if (ev->buffer.base != NULL)
        free_buffer(disp, ev->buffer.base, ev->buffer.length);
    free_event(disp, ev);

    if (response)
        do_next_response(disp, resp);
    else
        do_next_request(disp, resp);

    if (disp->shutting_down == 0)
        startrecv(disp);

    UNLOCK(&disp->lock);
}

static void
do_next_response(dns_dispatch_t *disp, dns_dispentry_t *resp) {
    dns_dispatchevent_t *ev;

    INSIST(resp->item_out == ISC_FALSE);

    ev = ISC_LIST_HEAD(resp->items);
    if (ev == NULL) {
        if (disp->shutting_down == 1)
            do_cancel(disp, NULL); /* was resp */
        return;
    }

    ISC_LIST_UNLINK(disp->rq_events, ev, ev_link);

    ISC_EVENT_INIT(ev, sizeof(*ev), 0, NULL, DNS_EVENT_DISPATCH,
               resp->action, resp->arg, resp, NULL, NULL);
    resp->item_out = ISC_TRUE;
    request_log(disp, resp, LVL(90),
            "[c] Sent event %p buffer %p len %d to task %p",
            ev, ev->buffer.base, ev->buffer.length,
            resp->task);
    isc_task_send(resp->task, (isc_event_t **)&ev);
}

static void
do_next_request(dns_dispatch_t *disp, dns_dispentry_t *resp) {
    dns_dispatchevent_t *ev;

    INSIST(resp->item_out == ISC_FALSE);

    ev = ISC_LIST_HEAD(disp->rq_events);
    if (ev == NULL) {
        if (disp->shutting_down == 1)
            do_cancel(disp, NULL); /* was resp */
        return;
    }

    ISC_LIST_UNLINK(disp->rq_events, ev, ev_link);

    ISC_EVENT_INIT(ev, sizeof(*ev), 0, NULL, DNS_EVENT_DISPATCH,
               resp->action, resp->arg, resp, NULL, NULL);
    resp->item_out = ISC_TRUE;
    request_log(disp, resp, LVL(90),
            "[d] Sent event %p buffer %p len %d to task %p",
            ev, ev->buffer.base, ev->buffer.length, resp->task);
    isc_task_send(resp->task, (isc_event_t **)&ev);
}

static void
do_cancel(dns_dispatch_t *disp, dns_dispentry_t *resp) {
    dns_dispatchevent_t *ev;

    if (disp->shutdown_out == 1)
        return;

    request_log(disp, resp, LVL(90), "cancel");

    /*
     * If no target given, find the first request handler.  If
     * there are packets waiting for any handler, however, don't
     * kill them.
     */
    if (resp == NULL) {
        if (ISC_LIST_EMPTY(disp->rq_events)) {
            resp = ISC_LIST_HEAD(disp->rq_handlers);
            while (resp != NULL) {
                if (resp->item_out == ISC_FALSE)
                    break;
                resp = ISC_LIST_NEXT(resp, link);
            }
        }
    }

    /*
     * Search for the first response handler without packets outstanding.
     */
    if (resp == NULL) {
        resp = linear_first(disp);
        if (resp == NULL)  /* no first item? */
            return;
        do {
            if (resp->item_out == ISC_FALSE)
                break;

            resp = linear_next(disp, resp);
        } while (resp != NULL);
    }

    /*
     * No one to send the cancel event to, so nothing to do.
     */
    if (resp == NULL)
        return;

    /*
     * Send the shutdown failsafe event to this resp.
     */
    ev = disp->failsafe_ev;
    ISC_EVENT_INIT(ev, sizeof (*ev), 0, NULL, DNS_EVENT_DISPATCH,
               resp->action, resp->arg, resp, NULL, NULL);
    ev->result = disp->shutdown_why;
    ev->buffer.base = NULL;
    ev->buffer.length = 0;
    disp->shutdown_out = 1;
    request_log(disp, resp, LVL(10),
            "sent failsafe event %p to task %p", ev, resp->task);
    resp->item_out = ISC_TRUE;
    isc_task_send(resp->task, (isc_event_t **)&ev);
}

isc_socket_t *
dns_dispatch_getsocket(dns_dispatch_t *disp) {
    REQUIRE(VALID_DISPATCH(disp));

    return (disp->socket);
}

void
dns_dispatch_cancel(dns_dispatch_t *disp) {
    REQUIRE(VALID_DISPATCH(disp));

    LOCK(&disp->lock);

    if (disp->shutting_down == 1) {
        UNLOCK(&disp->lock);
        return;
    }

    disp->shutdown_why = ISC_R_CANCELED;
    disp->shutting_down = 1;
    do_cancel(disp, NULL);

    UNLOCK(&disp->lock);

    return;
}

void
dns_dispatch_changeattributes(dns_dispatch_t *disp,
                  unsigned int attributes, unsigned int mask)
{
    LOCK(&disp->mgr->lock);
    LOCK(&disp->lock);
    disp->attributes &= ~mask;
    disp->attributes |= (attributes & mask);
    UNLOCK(&disp->lock);
    UNLOCK(&disp->mgr->lock);
}

#if 0
void
dns_dispatchmgr_dump(dns_dispatchmgr_t *mgr) {
    dns_dispatch_t *disp;
    char foo[1024];

    disp = ISC_LIST_HEAD(mgr->list);
    while (disp != NULL) {
        isc_sockaddr_format(&disp->local, foo, sizeof foo);
        printf("dispatch %p, addr %s\n", disp, foo);
        disp = ISC_LIST_NEXT(disp, link);
    }
}
#endif