lib/dns/dispatch.c

	dispatch.c revision d1ba6e9180c7d7458656a6e53e52fde056fd244c
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer/*
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer * Copyright (C) 1999  Internet Software Consortium.
0c27b3fe77ac1d5094ba3521e8142d9e7973133fMark Andrews *
bf8267aa453e5d2a735ed732a043b77a0b355b20Mark Andrews * Permission to use, copy, modify, and distribute this software for any
0c27b3fe77ac1d5094ba3521e8142d9e7973133fMark Andrews * purpose with or without fee is hereby granted, provided that the above
0c27b3fe77ac1d5094ba3521e8142d9e7973133fMark Andrews * copyright notice and this permission notice appear in all copies.
0c27b3fe77ac1d5094ba3521e8142d9e7973133fMark Andrews *
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
70e5a7403f0e0a3bd292b8287c5fed5772c15270Automatic Updater * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
9c3531d72aeaad6c5f01efe6a1c82023e1379e4dDavid Lawrence * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
813d6c9781d1fb48bb5c1d6d3415e65f7be5eeb0Andreas Gustafsson * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
813d6c9781d1fb48bb5c1d6d3415e65f7be5eeb0Andreas Gustafsson * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
813d6c9781d1fb48bb5c1d6d3415e65f7be5eeb0Andreas Gustafsson * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer * SOFTWARE.
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer */
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer#include <config.h>
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer
931e154a1e597ab183b2a0cece9401f361a47f06Michael Sawyer#include <ctype.h>
a2b565626ba9a98eecc7b82cb86c6d68c38d3d94Michael Sawyer#include <stdio.h>
1e8c2e72e7d0f48ac37b9b15712e638631b3b619Brian Wellington#include <stdlib.h>
fa7ee558e0536a94bfdb154a7c7ba298535459c4Mark Andrews#include <string.h>
a2b565626ba9a98eecc7b82cb86c6d68c38d3d94Michael Sawyer
a2b565626ba9a98eecc7b82cb86c6d68c38d3d94Michael Sawyer#include <isc/assertions.h>
a2b565626ba9a98eecc7b82cb86c6d68c38d3d94Michael Sawyer#include <isc/error.h>
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer#include <isc/mem.h>
a2b565626ba9a98eecc7b82cb86c6d68c38d3d94Michael Sawyer#include <isc/mutex.h>
931e154a1e597ab183b2a0cece9401f361a47f06Michael Sawyer#include <isc/socket.h>
6c3bd0545ac22ab1b41c9820183aca662afe07b9Brian Wellington
a2b565626ba9a98eecc7b82cb86c6d68c38d3d94Michael Sawyer#include <dns/events.h>
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer#include <dns/types.h>
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer#include <dns/result.h>
9e411a82b2c5ff3b9b36f1f44ea35a70ab7a6760Andreas Gustafsson#include <dns/dispatch.h>
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer#include <dns/message.h>
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer
722cac3cdcc5385ab64fa2d6c7f48ce3b9a68331Andreas Gustafsson#include "../isc/util.h"
722cac3cdcc5385ab64fa2d6c7f48ce3b9a68331Andreas Gustafsson
813d6c9781d1fb48bb5c1d6d3415e65f7be5eeb0Andreas Gustafsson/*
722cac3cdcc5385ab64fa2d6c7f48ce3b9a68331Andreas Gustafsson * If we cannot send to this task, the application is broken.
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer */
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer#define ISC_TASK_SEND(a, b) do { \
813d6c9781d1fb48bb5c1d6d3415e65f7be5eeb0Andreas Gustafsson    RUNTIME_CHECK(isc_task_send(a, b) == ISC_R_SUCCESS); \
722cac3cdcc5385ab64fa2d6c7f48ce3b9a68331Andreas Gustafsson} while (0)
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer
722cac3cdcc5385ab64fa2d6c7f48ce3b9a68331Andreas Gustafssonstruct dns_dispentry {
02bc88821c5c853027b20199d178b321093ad2ceMichael Sawyer    unsigned int            magic;
6c52944ef2281095d1c317a45ea013b8f3cfa135Mark Andrews    dns_messageid_t         id;
a2b565626ba9a98eecc7b82cb86c6d68c38d3d94Michael Sawyer    unsigned int            bucket;
813d6c9781d1fb48bb5c1d6d3415e65f7be5eeb0Andreas Gustafsson    isc_sockaddr_t          host;
722cac3cdcc5385ab64fa2d6c7f48ce3b9a68331Andreas Gustafsson    isc_task_t             *task;
a2b565626ba9a98eecc7b82cb86c6d68c38d3d94Michael Sawyer    isc_taskaction_t        action;
a2b565626ba9a98eecc7b82cb86c6d68c38d3d94Michael Sawyer    void                   *arg;
813d6c9781d1fb48bb5c1d6d3415e65f7be5eeb0Andreas Gustafsson    isc_boolean_t           item_out;
722cac3cdcc5385ab64fa2d6c7f48ce3b9a68331Andreas Gustafsson    ISC_LIST(dns_dispatchevent_t)   items;
a2b565626ba9a98eecc7b82cb86c6d68c38d3d94Michael Sawyer    ISC_LINK(dns_dispentry_t)   link;
a2b565626ba9a98eecc7b82cb86c6d68c38d3d94Michael Sawyer};
722cac3cdcc5385ab64fa2d6c7f48ce3b9a68331Andreas Gustafsson
a2b565626ba9a98eecc7b82cb86c6d68c38d3d94Michael Sawyer#define INVALID_BUCKET (0xffffdead)
1e8c2e72e7d0f48ac37b9b15712e638631b3b619Brian Wellington
3635d8f9104e70e141a8f191a0e6c1502ceed2f3Mark Andrewstypedef ISC_LIST(dns_dispentry_t)   dns_displist_t;

struct dns_dispatch {
    /* Unlocked. */
    unsigned int        magic;      /* magic */
    isc_mem_t          *mctx;       /* memory context */
    isc_task_t         *task;       /* internal task */
    isc_socket_t           *socket;     /* isc socket attached to */
    unsigned int        buffersize; /* size of each buffer */

    /* Locked. */
    isc_mutex_t     lock;       /* locks all below */
    unsigned int        refcount;   /* number of users */
    isc_mempool_t          *epool;      /* memory pool for events */
    isc_mempool_t          *bpool;      /* memory pool for buffers */
    isc_mempool_t          *rpool;      /* memory pool request/reply */
    dns_dispatchevent_t    *failsafe_ev;    /* failsafe cancel event */
    unsigned int        recvs;      /* recv() calls outstanding */
    unsigned int        recvs_wanted;   /* recv() calls wanted */
    unsigned int        shutting_down : 1,
                shutdown_out : 1;
    dns_result_t        shutdown_why;
    unsigned int        requests;   /* how many requests we have */
    ISC_LIST(dns_dispentry_t) rq_handlers;  /* request handler list */
    ISC_LIST(dns_dispatchevent_t) rq_events; /* holder for rq events */
    isc_int32_t     qid_state;  /* state generator info */
    unsigned int        qid_hashsize;   /* hash table size */
    unsigned int        qid_mask;   /* mask for hash table */
    dns_displist_t          *qid_table; /* the table itself */
};

#define REQUEST_MAGIC   0x53912051 /* "random" value */
#define VALID_REQUEST(e)  ((e) != NULL && (e)->magic == REQUEST_MAGIC)

#define RESPONSE_MAGIC  0x15021935 /* "random" value */
#define VALID_RESPONSE(e)  ((e) != NULL && (e)->magic == RESPONSE_MAGIC)

#define DISPATCH_MAGIC  0x69385829 /* "random" value */
#define VALID_DISPATCH(e)  ((e) != NULL && (e)->magic == DISPATCH_MAGIC)

/*
 * statics.
 */
static dns_dispentry_t *
bucket_search(dns_dispatch_t *, isc_sockaddr_t *,
          dns_messageid_t, unsigned int);

static void
destroy(dns_dispatch_t *);

static void
udp_recv(isc_task_t *, isc_event_t *);

static void
startrecv(dns_dispatch_t *);

static dns_messageid_t
randomid(dns_dispatch_t *);

static unsigned int
hash(dns_dispatch_t *, isc_sockaddr_t *, dns_messageid_t);

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

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

static inline void
free_event(dns_dispatch_t *disp, dns_dispatchevent_t *ev);

static inline dns_dispatchevent_t *
allocate_event(dns_dispatch_t *disp);

static inline isc_boolean_t
ok_to_kill(dns_dispatch_t *disp);

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

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

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

static dns_dispentry_t *
linear_first(dns_dispatch_t *disp);

static dns_dispentry_t *
linear_next(dns_dispatch_t *disp, dns_dispentry_t *resp);

static dns_dispentry_t *
linear_first(dns_dispatch_t *disp)
{
    dns_dispentry_t *ret;
    unsigned int bucket;

    bucket = 0;

    while (bucket < disp->qid_hashsize) {
        ret = ISC_LIST_HEAD(disp->qid_table[bucket]);
        if (ret != NULL)
            return (ret);
        bucket++;
    }

    return (NULL);
}

static dns_dispentry_t *
linear_next(dns_dispatch_t *disp, dns_dispentry_t *resp)
{
    dns_dispentry_t *ret;
    unsigned int bucket;

    ret = ISC_LIST_NEXT(resp, link);
    if (ret != NULL)
        return (ret);

    bucket = resp->bucket;
    while (bucket < disp->qid_hashsize) {
        ret = ISC_LIST_HEAD(disp->qid_table[bucket]);
        if (ret != NULL)
            return (ret);
        bucket++;
    }

    return (NULL);
}

/*
 * Return a hash of the destination and message id.  For now, just return
 * the message id bits, and mask off the low order bits of that.
 */
static unsigned int
hash(dns_dispatch_t *disp, isc_sockaddr_t *dest, dns_messageid_t id)
{
    unsigned int ret;

    (void)dest;  /* shut up compiler warning. */

    ret = id;
    ret &= disp->qid_mask;

    return (ret);
}

/*
 * Return a random message ID.  For now this isn't too clever...
 * XXXMLG
 */
static dns_messageid_t
randomid(dns_dispatch_t *disp)
{
    disp->qid_state++;

    return ((dns_messageid_t)disp->qid_state);
}

static inline isc_boolean_t
ok_to_kill(dns_dispatch_t *disp)
{
    if (disp->recvs > 0)
        return (ISC_FALSE);

    if (disp->refcount > 0)
        return (ISC_FALSE);

    INSIST(disp->requests == 0);

    return (ISC_TRUE);
}

/*
 * Called when refcount reaches 0 at any time.
 */
static void
destroy(dns_dispatch_t *disp)
{
    dns_dispatchevent_t *ev;

    disp->magic = 0;

    isc_task_detach(&disp->task);
    isc_socket_detach(&disp->socket);

    /*
     * Final cleanup of packets on the request list.
     */
    ev = ISC_LIST_HEAD(disp->rq_events);
    while (ev != NULL) {
        ISC_LIST_UNLINK(disp->rq_events, ev, link);
        free_buffer(disp, ev->buffer.base, ev->buffer.length);
        free_event(disp, ev);
        ev = ISC_LIST_HEAD(disp->rq_events);
    }

    isc_mempool_put(disp->epool, disp->failsafe_ev);
    disp->failsafe_ev = NULL;

    isc_mempool_destroy(&disp->rpool);
    isc_mempool_destroy(&disp->bpool);
    isc_mempool_destroy(&disp->epool);
    isc_mem_put(disp->mctx, disp->qid_table,
            disp->qid_hashsize * sizeof(void *));

    isc_mem_put(disp->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;

    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)
{
    if (len == disp->buffersize)
        isc_mempool_put(disp->bpool, buf);
    else
        isc_mem_put(disp->mctx, buf, len);
}

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->mctx, len);

    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->arg;
    dns_messageid_t id;
    dns_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;

    (void)task;  /* shut up compiler */

    printf("Got packet!\n");

    LOCK(&disp->lock);

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

    if (ev->result != ISC_R_SUCCESS) {
        /*
         * If the recv() was canceled pass the word on.
         */
        if (ev->result == ISC_R_CANCELED) {
            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);

            isc_event_free(&ev_in);
            return;
        }

        /*
         * otherwise, on strange error, log it and restart.
         * XXXMLG
         */
        free_buffer(disp, ev->region.base, ev->region.length);
        goto restart;
    }

    printf("length == %d, buflen = %d, addr = %p\n",
           ev->n, ev->region.length, ev->region.base);

    /*
     * Peek into the buffer to see what we can see.
     */
    isc_buffer_init(&source, ev->region.base, ev->region.length,
            ISC_BUFFERTYPE_BINARY);
    isc_buffer_add(&source, ev->n);
    dres = dns_message_peekheader(&source, &id, &flags);
    if (dres != DNS_R_SUCCESS) {
        free_buffer(disp, ev->region.base, ev->region.length);
        printf("dns_message_peekheader(): %s\n",
               isc_result_totext(dres));
        /* XXXMLG log something here... */
        goto restart;
    }

    printf("Got valid DNS message header, /QR %c, id %d\n",
           ((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.
     */
    if ((flags & DNS_MESSAGEFLAG_QR) == 0) {
        resp = ISC_LIST_HEAD(disp->rq_handlers);
        if (resp == NULL) {
            free_buffer(disp, ev->region.base, ev->region.length);
            goto restart;
        }
        rev = allocate_event(disp);
        if (rev == NULL) {
            free_buffer(disp, ev->region.base, ev->region.length);
            goto restart;
        }
        /* query */
    } else {
        /* response */
        bucket = hash(disp, &ev->address, id);
        resp = bucket_search(disp, &ev->address, id, bucket);
        if (resp == NULL) {
            free_buffer(disp, ev->region.base, ev->region.length);
            goto restart;
        }
        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_EVENT_INIT(rev, sizeof(*rev), 0, 0, DNS_EVENT_DISPATCH,
               resp->action, resp->arg, resp, NULL, NULL);
    isc_buffer_init(&rev->buffer, ev->region.base, ev->region.length,
            ISC_BUFFERTYPE_BINARY);
    isc_buffer_add(&rev->buffer, ev->n);
    rev->result = DNS_R_SUCCESS;
    rev->id = id;
    rev->addr = ev->address;
    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;

    printf("Starting receive\n");

    socktype = isc_socket_gettype(disp->socket);

    while (disp->recvs < wanted) {
        switch (socktype) {
            /*
             * UDP reads are always maximal.
             */
        case isc_socket_udp:
            region.length = disp->buffersize;
            region.base = allocate_buffer(disp, disp->buffersize);
            if (region.base == NULL)
                return;
            printf("Recv into %p, length %d\n", region.base,
                   region.length);
            res = isc_socket_recv(disp->socket, &region, ISC_TRUE,
                          disp->task, udp_recv, disp);
            if (res != ISC_R_SUCCESS) {
                disp->shutdown_why = res;
                do_cancel(disp, NULL);
                return;
            }
            disp->recvs++;
            break;

        case isc_socket_tcp:
            INSIST(1); /* XXXMLG */
            break;
        }
    }
}

/*
 * Publics.
 */

dns_result_t
dns_dispatch_create(isc_mem_t *mctx, isc_socket_t *sock, isc_task_t *task,
            unsigned int maxbuffersize,
            unsigned int maxbuffers, unsigned int maxrequests,
            unsigned int hashsize, dns_dispatch_t **dispp)
{
    dns_dispatch_t *disp;
    unsigned int tablesize;
    dns_result_t res;
    isc_sockettype_t socktype;
    unsigned int i;

    REQUIRE(mctx != NULL);
    REQUIRE(sock != NULL);
    REQUIRE(task != NULL);
    REQUIRE(hashsize <= 24);
    REQUIRE(maxbuffersize >= 512 && maxbuffersize < (64 * 1024));
    REQUIRE(maxbuffers > 0);
    REQUIRE(maxrequests <= maxbuffers);
    REQUIRE(dispp != NULL && *dispp == NULL);

    socktype = isc_socket_gettype(sock);
    REQUIRE(socktype == isc_socket_udp || socktype == isc_socket_tcp);

    res = DNS_R_SUCCESS;

    disp = isc_mem_get(mctx, sizeof(dns_dispatch_t));
    if (disp == NULL)
        return (DNS_R_NOMEMORY);

    disp->magic = 0;
    disp->mctx = mctx;
    disp->buffersize = maxbuffersize;
    disp->refcount = 1;
    disp->recvs = 0;
    if (socktype == isc_socket_udp)
        disp->recvs_wanted = 8; /* XXXMLG config option */
    else
        disp->recvs_wanted = 1;
    disp->shutting_down = 0;
    disp->shutdown_out = 0;
    disp->shutdown_why = ISC_R_UNEXPECTED;
    disp->requests = 0;
    ISC_LIST_INIT(disp->rq_handlers);
    ISC_LIST_INIT(disp->rq_events);

    tablesize = (1 << hashsize);

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

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

    disp->qid_mask = tablesize - 1;
    disp->qid_hashsize = tablesize;

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

    disp->epool = NULL;
    if (isc_mempool_create(mctx, sizeof(dns_dispatchevent_t),
                   &disp->epool) != ISC_R_SUCCESS) {
        res = DNS_R_NOMEMORY;
        goto out3;
    }

    disp->bpool = NULL;
    if (isc_mempool_create(mctx, maxbuffersize,
                   &disp->bpool) != ISC_R_SUCCESS) {
        res = DNS_R_NOMEMORY;
        goto out4;
    }

    disp->rpool = NULL;
    if (isc_mempool_create(mctx, sizeof(dns_dispentry_t),
                   &disp->rpool) != ISC_R_SUCCESS) {
        res = DNS_R_NOMEMORY;
        goto out5;
    }

    /*
     * 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 = DNS_R_NOMEMORY;
        goto out6;
    }

    /*
     * should initialize qid_state here XXXMLG
     */
    disp->qid_state = (unsigned int)disp;

    disp->magic = DISPATCH_MAGIC;

    disp->task = NULL;
    isc_task_attach(task, &disp->task);
    disp->socket = NULL;
    isc_socket_attach(sock, &disp->socket);

    *dispp = disp;

    return (DNS_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(mctx, disp->mctx, disp->qid_hashsize * sizeof(void *));
 out1:
    isc_mem_put(mctx, disp, sizeof(dns_dispatch_t));

    return (res);
}

void
dns_dispatch_destroy(dns_dispatch_t **dispp)
{
    dns_dispatch_t *disp;
    isc_boolean_t killit;

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

    disp = *dispp;
    *dispp = NULL;

    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;
    }

    printf("dns_dispatch_destory:  refcount = %d\n", disp->refcount);

    UNLOCK(&disp->lock);

    if (killit)
        destroy(disp);
}

dns_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);

    /*
     * Try somewhat hard to find an unique ID.
     */
    id = randomid(disp);
    bucket = 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 = randomid(disp);
        bucket = hash(disp, dest, id);
    }

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

    res = isc_mempool_get(disp->rpool);
    if (res == NULL) {
        UNLOCK(&disp->lock);
        return (DNS_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);

    startrecv(disp);

    UNLOCK(&disp->lock);

    *idp = id;
    *resp = res;

    return (DNS_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;

    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;
    }

    res->magic = 0;
    bucket = res->bucket;

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

    isc_task_detach(&res->task);

    isc_mempool_put(disp->rpool, res);
    if (ev != NULL) {
        free_buffer(disp, ev->buffer.base, ev->buffer.length);
        free_event(disp, ev);
    }
    if (disp->shutting_down == 1)
        do_cancel(disp, NULL);

    startrecv(disp);

    UNLOCK(&disp->lock);

    if (killit)
        destroy(disp);
}

dns_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);

    res = isc_mempool_get(disp->rpool);
    if (res == NULL) {
        UNLOCK(&disp->lock);
        return (DNS_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);

    startrecv(disp);

    UNLOCK(&disp->lock);

    *resp = res;

    return (DNS_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;

    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;
    }

    res->magic = 0;

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

    isc_task_detach(&res->task);

    isc_mempool_put(disp->rpool, res);
    if (ev != NULL) {
        if (ev->buffer.length != 0)
            free_buffer(disp, ev->buffer.base, ev->buffer.length);
        free_event(disp, ev);
    }

    startrecv(disp);

    UNLOCK(&disp->lock);

    if (killit)
        destroy(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);

    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);

    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, resp);
        return;
    }

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

    ISC_EVENT_INIT(ev, sizeof(*ev), 0, 0, DNS_EVENT_DISPATCH,
               resp->action, resp->arg, resp, NULL, NULL);
    resp->item_out = ISC_TRUE;
    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, resp);
        return;
    }

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

    ISC_EVENT_INIT(ev, sizeof(*ev), 0, 0, DNS_EVENT_DISPATCH,
               resp->action, resp->arg, resp, NULL, NULL);
    resp->item_out = ISC_TRUE;
    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;

    /*
     * 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) {
        resp = ISC_LIST_HEAD(disp->rq_handlers);
        if (resp != NULL && resp->item_out == ISC_FALSE)
            resp = NULL;
    }

    /*
     * Search for the first responce 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, 0, DNS_EVENT_DISPATCH,
               resp->action, resp->arg, resp, NULL, NULL);
    ev->result = ISC_R_CANCELED;
    ev->buffer.base = NULL;
    ev->buffer.length = 0;
    ISC_TASK_SEND(resp->task, (isc_event_t **)&ev);
}