Remove building with NOCRYPTO option

[minix3.git] / minix / lib / libsockevent / sockevent.c

/* Socket event dispatching library - by D.C. van Moolenbroek */

#include <minix/drivers.h>
#include <minix/sockdriver.h>
#include <minix/sockevent.h>
#include <sys/ioctl.h>

#include "sockevent_proc.h"

#define US              1000000UL       /* microseconds per second */

#define SOCKHASH_SLOTS  256             /* # slots in ID-to-sock hash table */

static SLIST_HEAD(, sock) sockhash[SOCKHASH_SLOTS];

static SLIST_HEAD(, sock) socktimer;

static minix_timer_t sockevent_timer;

static SIMPLEQ_HEAD(, sock) sockevent_pending;

static sockevent_socket_cb_t sockevent_socket_cb = NULL;

static int sockevent_working;

static void socktimer_del(struct sock * sock);
static void sockevent_cancel_send(struct sock * sock,
        struct sockevent_proc * spr, int err);
static void sockevent_cancel_recv(struct sock * sock,
        struct sockevent_proc * spr, int err);

/*
 * Initialize the hash table of sock objects.
 */
static void
sockhash_init(void)
{
        unsigned int slot;

        for (slot = 0; slot < __arraycount(sockhash); slot++)
                SLIST_INIT(&sockhash[slot]);
}

/*
 * Given a socket identifier, return a hash table slot number.
 */
static unsigned int
sockhash_slot(sockid_t id)
{

        /*
         * The idea of the shift is that a socket driver may offer multiple
         * classes of sockets, and put the class in the higher bits.  The shift
         * aims to prevent that all classes' first sockets end up in the same
         * hash slot.
         */
        return (id + (id >> 16)) % SOCKHASH_SLOTS;
}

/*
 * Obtain a sock object from the hash table using its unique identifier.
 * Return a pointer to the object if found, or NULL otherwise.
 */
static struct sock *
sockhash_get(sockid_t id)
{
        struct sock *sock;
        unsigned int slot;

        slot = sockhash_slot(id);

        SLIST_FOREACH(sock, &sockhash[slot], sock_hash) {
                if (sock->sock_id == id)
                        return sock;
        }

        return NULL;
}

/*
 * Add a sock object to the hash table.  The sock object must have a valid ID
 * in its 'sock_id' field, and must not be in the hash table already.
 */
static void
sockhash_add(struct sock * sock)
{
        unsigned int slot;

        slot = sockhash_slot(sock->sock_id);

        SLIST_INSERT_HEAD(&sockhash[slot], sock, sock_hash);
}

/*
 * Remove a sock object from the hash table.  The sock object must be in the
 * hash table.
 */
static void
sockhash_del(struct sock * sock)
{
        unsigned int slot;

        slot = sockhash_slot(sock->sock_id);

        /* This macro is O(n). */
        SLIST_REMOVE(&sockhash[slot], sock, sock, sock_hash);
}

/*
 * Reset a socket object to a proper initial state, with a particular socket
 * identifier, a SOCK_ type, and a socket operations table.  The socket is
 * added to the ID-to-object hash table.  This function always succeeds.
 */
static void
sockevent_reset(struct sock * sock, sockid_t id, int domain, int type,
        const struct sockevent_ops * ops)
{

        assert(sock != NULL);

        memset(sock, 0, sizeof(*sock));

        sock->sock_id = id;
        sock->sock_domain = domain;
        sock->sock_type = type;

        sock->sock_slowat = 1;
        sock->sock_rlowat = 1;

        sock->sock_ops = ops;
        sock->sock_proc = NULL;
        sock->sock_select.ss_endpt = NONE;

        sockhash_add(sock);
}

/*
 * Initialize a new socket that will serve as an accepted socket on the given
 * listening socket 'sock'.  The new socket is given as 'newsock', and its new
 * socket identifier is given as 'newid'.  This function always succeeds.
 */
void
sockevent_clone(struct sock * sock, struct sock * newsock, sockid_t newid)
{

        sockevent_reset(newsock, newid, (int)sock->sock_domain,
            sock->sock_type, sock->sock_ops);

        /* These are the settings that are currently inherited. */
        newsock->sock_opt = sock->sock_opt & ~SO_ACCEPTCONN;
        newsock->sock_linger = sock->sock_linger;
        newsock->sock_stimeo = sock->sock_stimeo;
        newsock->sock_rtimeo = sock->sock_rtimeo;
        newsock->sock_slowat = sock->sock_slowat;
        newsock->sock_rlowat = sock->sock_rlowat;

        newsock->sock_flags |= SFL_CLONED;
}

/*
 * A new socket has just been accepted.  The corresponding listening socket is
 * given as 'sock'.  The new socket has ID 'newid', and if it had not already
 * been added to the hash table through sockevent_clone() before, 'newsock' is
 * a non-NULL pointer which identifies the socket object to clone into.
 */
static void
sockevent_accepted(struct sock * sock, struct sock * newsock, sockid_t newid)
{

        if (newsock == NULL) {
                if ((newsock = sockhash_get(newid)) == NULL)
                        panic("libsockdriver: socket driver returned unknown "
                            "ID %d from accept callback", newid);
        } else
                sockevent_clone(sock, newsock, newid);

        assert(newsock->sock_flags & SFL_CLONED);
        newsock->sock_flags &= ~SFL_CLONED;
}

/*
 * Allocate a sock object, by asking the socket driver for one.  On success,
 * return OK, with a pointer to the new object stored in 'sockp'.  This new
 * object has all its fields set to initial values, in part based on the given
 * parameters.  On failure, return an error code.  Failure has two typical
 * cause: either the given domain, type, protocol combination is not supported,
 * or the socket driver is out of sockets (globally or for this combination).
 */
static int
sockevent_alloc(int domain, int type, int protocol, endpoint_t user_endpt,
        struct sock ** sockp)
{
        struct sock *sock;
        const struct sockevent_ops *ops;
        sockid_t r;

        /*
         * Verify that the given domain is sane.  Unlike the type and protocol,
         * the domain is already verified by VFS, so we do not limit ourselves
         * here.  The result is that we can store the domain in just a byte.
         */
        if (domain < 0 || domain > UINT8_MAX)
                return EAFNOSUPPORT;

        /* Make sure that the library has actually been initialized. */
        if (sockevent_socket_cb == NULL)
                panic("libsockevent: not initialized");

        sock = NULL;
        ops = NULL;

        /*
         * Ask the socket driver to create a socket for the given combination
         * of domain, type, and protocol.  If so, let it return a new sock
         * object, a unique socket identifier for that object, and an
         * operations table for it.
         */
        if ((r = sockevent_socket_cb(domain, type, protocol, user_endpt, &sock,
            &ops)) < 0)
                return r;

        assert(sock != NULL);
        assert(ops != NULL);

        sockevent_reset(sock, r, domain, type, ops);

        *sockp = sock;
        return OK;
}

/*
 * Free a previously allocated sock object.
 */
static void
sockevent_free(struct sock * sock)
{
        const struct sockevent_ops *ops;

        assert(sock->sock_proc == NULL);

        socktimer_del(sock);

        sockhash_del(sock);

        /*
         * Invalidate the operations table on the socket, before freeing the
         * socket.  This allows us to detect cases where sockevent functions
         * are called on sockets that have already been freed.
         */
        ops = sock->sock_ops;
        sock->sock_ops = NULL;

        assert(ops != NULL);
        assert(ops->sop_free != NULL);

        ops->sop_free(sock);
}

/*
 * Create a new socket.
 */
static sockid_t
sockevent_socket(int domain, int type, int protocol, endpoint_t user_endpt)
{
        struct sock *sock;
        int r;

        if ((r = sockevent_alloc(domain, type, protocol, user_endpt,
            &sock)) != OK)
                return r;

        return sock->sock_id;
}

/*
 * Create a pair of connected sockets.
 */
static int
sockevent_socketpair(int domain, int type, int protocol, endpoint_t user_endpt,
        sockid_t id[2])
{
        struct sock *sock1, *sock2;
        int r;

        if ((r = sockevent_alloc(domain, type, protocol, user_endpt,
            &sock1)) != OK)
                return r;

        /* Creating socket pairs is not always supported. */
        if (sock1->sock_ops->sop_pair == NULL) {
                sockevent_free(sock1);

                return EOPNOTSUPP;
        }

        if ((r = sockevent_alloc(domain, type, protocol, user_endpt,
            &sock2)) != OK) {
                sockevent_free(sock1);

                return r;
        }

        assert(sock1->sock_ops == sock2->sock_ops);

        r = sock1->sock_ops->sop_pair(sock1, sock2, user_endpt);

        if (r != OK) {
                sockevent_free(sock2);
                sockevent_free(sock1);

                return r;
        }

        id[0] = sock1->sock_id;
        id[1] = sock2->sock_id;
        return OK;
}

/*
 * A send request returned EPIPE.  If desired, send a SIGPIPE signal to the
 * user process that issued the request.
 */
static void
sockevent_sigpipe(struct sock * sock, endpoint_t user_endpt, int flags)
{

        /*
         * POSIX says that pipe signals should be generated for SOCK_STREAM
         * sockets.  Linux does just this, NetBSD raises signals for all socket
         * types.
         */
        if (sock->sock_type != SOCK_STREAM)
                return;

        /*
         * Why would there be fewer than four ways to do the same thing?
         * O_NOSIGPIPE, MSG_NOSIGNAL, SO_NOSIGPIPE, and of course blocking
         * SIGPIPE.  VFS already sets MSG_NOSIGNAL for calls on sockets with
         * O_NOSIGPIPE.  The fact that SO_NOSIGPIPE is a thing, is also the
         * reason why we cannot let VFS handle signal generation altogether.
         */
        if (flags & MSG_NOSIGNAL)
                return;
        if (sock->sock_opt & SO_NOSIGPIPE)
                return;

        /*
         * Send a SIGPIPE signal to the user process.  Unfortunately we cannot
         * guarantee that the SIGPIPE reaches the user process before the send
         * call returns.  Usually, the scheduling priorities of system services
         * are such that the signal is likely to arrive first anyway, but if
         * timely arrival of the signal is required, a more fundamental change
         * to the system would be needed.
         */
        sys_kill(user_endpt, SIGPIPE);
}

/*
 * Suspend a request without data, that is, a bind, connect, accept, or close
 * request.
 */
static void
sockevent_suspend(struct sock * sock, unsigned int event,
        const struct sockdriver_call * __restrict call, endpoint_t user_endpt)
{
        struct sockevent_proc *spr, **sprp;

        /* There is one slot for each process, so this should never fail. */
        if ((spr = sockevent_proc_alloc()) == NULL)
                panic("libsockevent: too many suspended processes");

        spr->spr_next = NULL;
        spr->spr_event = event;
        spr->spr_timer = FALSE;
        spr->spr_call = *call;
        spr->spr_endpt = user_endpt;

        /*
         * Add the request to the tail of the queue.  This operation is O(n),
         * but the number of suspended requests per socket is expected to be
         * low at all times.
         */
        for (sprp = &sock->sock_proc; *sprp != NULL;
             sprp = &(*sprp)->spr_next);
        *sprp = spr;
}

/*
 * Suspend a request with data, that is, a send or receive request.
 */
static void
sockevent_suspend_data(struct sock * sock, unsigned int event, int timer,
        const struct sockdriver_call * __restrict call, endpoint_t user_endpt,
        const struct sockdriver_data * __restrict data, size_t len, size_t off,
        const struct sockdriver_data * __restrict ctl, socklen_t ctl_len,
        socklen_t ctl_off, int flags, int rflags, clock_t time)
{
        struct sockevent_proc *spr, **sprp;

        /* There is one slot for each process, so this should never fail. */
        if ((spr = sockevent_proc_alloc()) == NULL)
                panic("libsockevent: too many suspended processes");

        spr->spr_next = NULL;
        spr->spr_event = event;
        spr->spr_timer = timer;
        spr->spr_call = *call;
        spr->spr_endpt = user_endpt;
        sockdriver_pack_data(&spr->spr_data, call, data, len);
        spr->spr_datalen = len;
        spr->spr_dataoff = off;
        sockdriver_pack_data(&spr->spr_ctl, call, ctl, ctl_len);
        spr->spr_ctllen = ctl_len;
        spr->spr_ctloff = ctl_off;
        spr->spr_flags = flags;
        spr->spr_rflags = rflags;
        spr->spr_time = time;

        /*
         * Add the request to the tail of the queue.  This operation is O(n),
         * but the number of suspended requests per socket is expected to be
         * low at all times.
         */
        for (sprp = &sock->sock_proc; *sprp != NULL;
             sprp = &(*sprp)->spr_next);
        *sprp = spr;
}

/*
 * Return TRUE if there are any suspended requests on the given socket's queue
 * that match any of the events in the given event mask, or FALSE otherwise.
 */
static int
sockevent_has_suspended(struct sock * sock, unsigned int mask)
{
        struct sockevent_proc *spr;

        for (spr = sock->sock_proc; spr != NULL; spr = spr->spr_next)
                if (spr->spr_event & mask)
                        return TRUE;

        return FALSE;
}

/*
 * Check whether the given call is on the given socket's queue of suspended
 * requests.  If so, remove it from the queue and return a pointer to the
 * suspension data structure.  The caller is then responsible for freeing that
 * data structure using sockevent_proc_free().  If the call was not found, the
 * function returns NULL.
 */
static struct sockevent_proc *
sockevent_unsuspend(struct sock * sock, const struct sockdriver_call * call)
{
        struct sockevent_proc *spr, **sprp;

        /* Find the suspended request being canceled. */
        for (sprp = &sock->sock_proc; (spr = *sprp) != NULL;
            sprp = &spr->spr_next) {
                if (spr->spr_call.sc_endpt == call->sc_endpt &&
                    spr->spr_call.sc_req == call->sc_req) {
                        /* Found; remove and return it. */
                        *sprp = spr->spr_next;

                        return spr;
                }
        }

        return NULL;
}

/*
 * Attempt to resume the given suspended request for the given socket object.
 * Return TRUE if the suspended request has been fully resumed and can be
 * removed from the queue of suspended requests, or FALSE if it has not been
 * fully resumed and should stay on the queue.  In the latter case, no
 * resumption will be attempted for other suspended requests of the same type.
 */
static int
sockevent_resume(struct sock * sock, struct sockevent_proc * spr)
{
        struct sock *newsock;
        struct sockdriver_data data, ctl;
        char addr[SOCKADDR_MAX];
        socklen_t addr_len;
        size_t len, min;
        sockid_t r;

        switch (spr->spr_event) {
        case SEV_CONNECT:
                /*
                 * If the connect call was suspended for the purpose of
                 * intercepting resumption, simply remove it from the queue.
                 */
                if (spr->spr_call.sc_endpt == NONE)
                        return TRUE;

                /* FALLTHROUGH */
        case SEV_BIND:
                if ((r = sock->sock_err) != OK)
                        sock->sock_err = OK;

                sockdriver_reply_generic(&spr->spr_call, r);

                return TRUE;

        case SEV_ACCEPT:
                /*
                 * A previous accept call may not have blocked on a socket that
                 * was not in listening mode.
                 */
                assert(sock->sock_opt & SO_ACCEPTCONN);

                addr_len = 0;
                newsock = NULL;

                /*
                 * This call is suspended, which implies that the call table
                 * pointer has already tested to be non-NULL.
                 */
                if ((r = sock->sock_ops->sop_accept(sock,
                    (struct sockaddr *)&addr, &addr_len, spr->spr_endpt,
                    &newsock)) == SUSPEND)
                        return FALSE;

                if (r >= 0) {
                        assert(addr_len <= sizeof(addr));

                        sockevent_accepted(sock, newsock, r);
                }

                sockdriver_reply_accept(&spr->spr_call, r,
                    (struct sockaddr *)&addr, addr_len);

                return TRUE;

        case SEV_SEND:
                if (sock->sock_err != OK || (sock->sock_flags & SFL_SHUT_WR)) {
                        if (spr->spr_dataoff > 0 || spr->spr_ctloff > 0)
                                r = (int)spr->spr_dataoff;
                        else if ((r = sock->sock_err) != OK)
                                sock->sock_err = OK;
                        else
                                r = EPIPE;
                } else {
                        sockdriver_unpack_data(&data, &spr->spr_call,
                            &spr->spr_data, spr->spr_datalen);
                        sockdriver_unpack_data(&ctl, &spr->spr_call,
                            &spr->spr_ctl, spr->spr_ctllen);

                        len = spr->spr_datalen - spr->spr_dataoff;

                        min = sock->sock_slowat;
                        if (min > len)
                                min = len;

                        /*
                         * As mentioned elsewhere, we do not save the address
                         * upon suspension so we cannot supply it anymore here.
                         */
                        r = sock->sock_ops->sop_send(sock, &data, len,
                            &spr->spr_dataoff, &ctl,
                            spr->spr_ctllen - spr->spr_ctloff,
                            &spr->spr_ctloff, NULL, 0, spr->spr_endpt,
                            spr->spr_flags, min);

                        assert(r <= 0);

                        if (r == SUSPEND)
                                return FALSE;

                        /*
                         * If an error occurred but some data were already
                         * sent, return the progress rather than the error.
                         * Note that if the socket driver detects an
                         * asynchronous error during the send, it itself must
                         * perform this check and call sockevent_set_error() as
                         * needed, to make sure the error does not get lost.
                         */
                        if (spr->spr_dataoff > 0 || spr->spr_ctloff > 0)
                                r = spr->spr_dataoff;
                }

                if (r == EPIPE)
                        sockevent_sigpipe(sock, spr->spr_endpt,
                            spr->spr_flags);

                sockdriver_reply_generic(&spr->spr_call, r);

                return TRUE;

        case SEV_RECV:
                addr_len = 0;

                if (sock->sock_flags & SFL_SHUT_RD)
                        r = SOCKEVENT_EOF;
                else {
                        len = spr->spr_datalen - spr->spr_dataoff;

                        if (sock->sock_err == OK) {
                                min = sock->sock_rlowat;
                                if (min > len)
                                        min = len;
                        } else
                                min = 0;

                        sockdriver_unpack_data(&data, &spr->spr_call,
                            &spr->spr_data, spr->spr_datalen);
                        sockdriver_unpack_data(&ctl, &spr->spr_call,
                            &spr->spr_ctl, spr->spr_ctllen);

                        r = sock->sock_ops->sop_recv(sock, &data, len,
                            &spr->spr_dataoff, &ctl,
                            spr->spr_ctllen - spr->spr_ctloff,
                            &spr->spr_ctloff, (struct sockaddr *)&addr,
                            &addr_len, spr->spr_endpt, spr->spr_flags, min,
                            &spr->spr_rflags);

                        /*
                         * If the call remains suspended but a socket error is
                         * pending, return the pending socket error instead.
                         */
                        if (r == SUSPEND) {
                                if (sock->sock_err == OK)
                                        return FALSE;

                                r = SOCKEVENT_EOF;
                        }

                        assert(addr_len <= sizeof(addr));
                }

                /*
                 * If the receive call reported success, or if some data were
                 * already received, return the (partial) result.  Otherwise,
                 * return a pending error if any, or otherwise a regular error
                 * or 0 for EOF.
                 */
                if (r == OK || spr->spr_dataoff > 0 || spr->spr_ctloff > 0)
                        r = (int)spr->spr_dataoff;
                else if (sock->sock_err != OK) {
                        r = sock->sock_err;

                        sock->sock_err = OK;
                } else if (r == SOCKEVENT_EOF)
                        r = 0; /* EOF */

                sockdriver_reply_recv(&spr->spr_call, r, spr->spr_ctloff,
                    (struct sockaddr *)&addr, addr_len, spr->spr_rflags);

                return TRUE;

        case SEV_CLOSE:
                sockdriver_reply_generic(&spr->spr_call, OK);

                return TRUE;

        default:
                panic("libsockevent: process suspended on unknown event 0x%x",
                    spr->spr_event);
        }
}

/*
 * Return TRUE if the given socket is ready for reading for a select call, or
 * FALSE otherwise.
 */
static int
sockevent_test_readable(struct sock * sock)
{
        int r;

        /*
         * The meaning of "ready-to-read" depends on whether the socket is a
         * listening socket or not.  For the former, it is a test on whether
         * there are any new sockets to accept.  However, shutdown flags take
         * precedence in both cases.
         */
        if (sock->sock_flags & SFL_SHUT_RD)
                return TRUE;

        if (sock->sock_err != OK)
                return TRUE;

        /*
         * Depending on whether this is a listening-mode socket, test whether
         * either accepts or receives would block.
         */
        if (sock->sock_opt & SO_ACCEPTCONN) {
                if (sock->sock_ops->sop_test_accept == NULL)
                        return TRUE;

                r = sock->sock_ops->sop_test_accept(sock);
        } else {
                if (sock->sock_ops->sop_test_recv == NULL)
                        return TRUE;

                r = sock->sock_ops->sop_test_recv(sock, sock->sock_rlowat,
                    NULL);
        }

        return (r != SUSPEND);
}

/*
 * Return TRUE if the given socket is ready for writing for a select call, or
 * FALSE otherwise.
 */
static int
sockevent_test_writable(struct sock * sock)
{
        int r;

        if (sock->sock_err != OK)
                return TRUE;

        if (sock->sock_flags & SFL_SHUT_WR)
                return TRUE;

        if (sock->sock_ops->sop_test_send == NULL)
                return TRUE;

        /*
         * Test whether sends would block.  The low send watermark is relevant
         * for stream-type sockets only.
         */
        r = sock->sock_ops->sop_test_send(sock, sock->sock_slowat);

        return (r != SUSPEND);
}

/*
 * Test whether any of the given select operations are ready on the given
 * socket.  Return the subset of ready operations; zero if none.
 */
static unsigned int
sockevent_test_select(struct sock * sock, unsigned int ops)
{
        unsigned int ready_ops;

        assert(!(ops & ~(SDEV_OP_RD | SDEV_OP_WR | SDEV_OP_ERR)));

        /*
         * We do not support the "bind in progress" case here.  If a blocking
         * bind call is in progress, the file descriptor should not be ready
         * for either reading or writing.  Currently, socket drivers will have
         * to cover this case themselves.  Otherwise we would have to check the
         * queue of suspended calls, or create a custom flag for this.
         */

        ready_ops = 0;

        if ((ops & SDEV_OP_RD) && sockevent_test_readable(sock))
                ready_ops |= SDEV_OP_RD;

        if ((ops & SDEV_OP_WR) && sockevent_test_writable(sock))
                ready_ops |= SDEV_OP_WR;

        /* TODO: OOB receive support. */

        return ready_ops;
}

/*
 * Fire the given mask of events on the given socket object now.
 */
static void
sockevent_fire(struct sock * sock, unsigned int mask)
{
        struct sockevent_proc *spr, **sprp;
        unsigned int r, flag, ops;

        /*
         * A completed connection attempt (successful or not) also always
         * implies that the socket becomes writable.  For convenience we
         * enforce this rule here, because it is easy to forget.  Note that in
         * any case, a suspended connect request should be the first in the
         * list, so we do not risk returning 0 from a connect call as a result
         * of sock_err getting eaten by another resumed call.
         */
        if (mask & SEV_CONNECT)
                mask |= SEV_SEND;

        /*
         * First try resuming regular system calls.
         */
        for (sprp = &sock->sock_proc; (spr = *sprp) != NULL; ) {
                flag = spr->spr_event;

                if ((mask & flag) && sockevent_resume(sock, spr)) {
                        *sprp = spr->spr_next;

                        sockevent_proc_free(spr);
                } else {
                        mask &= ~flag;

                        sprp = &spr->spr_next;
                }
        }

        /*
         * Then see if we can satisfy pending select queries.
         */
        if ((mask & (SEV_ACCEPT | SEV_SEND | SEV_RECV)) &&
            sock->sock_select.ss_endpt != NONE) {
                assert(sock->sock_selops != 0);

                /*
                 * Only retest select operations that, based on the given event
                 * mask, could possibly be satisfied now.
                 */
                ops = sock->sock_selops;
                if (!(mask & (SEV_ACCEPT | SEV_RECV)))
                        ops &= ~SDEV_OP_RD;
                if (!(mask & SEV_SEND))
                        ops &= ~SDEV_OP_WR;
                if (!(0))                       /* TODO: OOB receive support */
                        ops &= ~SDEV_OP_ERR;

                /* Are there any operations to test? */
                if (ops != 0) {
                        /* Test those operations. */
                        r = sockevent_test_select(sock, ops);

                        /* Were any satisfied? */
                        if (r != 0) {
                                /* Let the caller know. */
                                sockdriver_reply_select(&sock->sock_select,
                                    sock->sock_id, r);

                                sock->sock_selops &= ~r;

                                /* Are there any saved operations left now? */
                                if (sock->sock_selops == 0)
                                        sock->sock_select.ss_endpt = NONE;
                        }
                }
        }

        /*
         * Finally, a SEV_CLOSE event unconditionally frees the sock object.
         * This event should be fired only for sockets that are either not yet,
         * or not anymore, in use by userland.
         */
        if (mask & SEV_CLOSE) {
                assert(sock->sock_flags & (SFL_CLONED | SFL_CLOSING));

                sockevent_free(sock);
        }
}

/*
 * Process all pending events.  Events must still be blocked, so that if
 * handling one event generates a new event, that event is handled from here
 * rather than immediately.
 */
static void
sockevent_pump(void)
{
        struct sock *sock;
        unsigned int mask;

        assert(sockevent_working);

        while (!SIMPLEQ_EMPTY(&sockevent_pending)) {
                sock = SIMPLEQ_FIRST(&sockevent_pending);
                SIMPLEQ_REMOVE_HEAD(&sockevent_pending, sock_next);

                mask = sock->sock_events;
                assert(mask != 0);
                sock->sock_events = 0;

                sockevent_fire(sock, mask);
                /*
                 * At this point, the sock object may already have been readded
                 * to the event list, or even be deallocated altogether.
                 */
        }
}

/*
 * Return TRUE if any events are pending on any sockets, or FALSE otherwise.
 */
static int
sockevent_has_events(void)
{

        return (!SIMPLEQ_EMPTY(&sockevent_pending));
}

/*
 * Raise the given bitwise-OR'ed set of events on the given socket object.
 * Depending on the context of the call, they events may or may not be
 * processed immediately.
 */
void
sockevent_raise(struct sock * sock, unsigned int mask)
{

        assert(sock->sock_ops != NULL);

        /*
         * Handle SEV_CLOSE first.  This event must not be deferred, so as to
         * let socket drivers recycle sock objects as they are needed.  For
         * example, a user-closed TCP socket may stay open to transmit the
         * remainder of its send buffer, until the TCP driver runs out of
         * sockets, in which case the connection is aborted.  The driver would
         * then raise SEV_CLOSE on the sock object so as to clean it up, and
         * immediately reuse it afterward.  If the close event were to be
         * deferred, this immediate reuse would not be possible.
         *
         * The sop_free() callback routine may not raise new events, and thus,
         * the state of 'sockevent_working' need not be checked or set here.
         */
        if (mask & SEV_CLOSE) {
                assert(mask == SEV_CLOSE);

                sockevent_fire(sock, mask);

                return;
        }

        /*
         * If we are currently processing a socket message, store the event for
         * later.  If not, this call is not coming from inside libsockevent,
         * and we must handle the event immediately.
         */
        if (sockevent_working) {
                assert(mask != 0);
                assert(mask <= UCHAR_MAX); /* sock_events field size check */

                if (sock->sock_events == 0)
                        SIMPLEQ_INSERT_TAIL(&sockevent_pending, sock,
                            sock_next);

                sock->sock_events |= mask;
        } else {
                sockevent_working = TRUE;

                sockevent_fire(sock, mask);

                if (sockevent_has_events())
                        sockevent_pump();

                sockevent_working = FALSE;
        }
}

/*
 * Set a pending error on the socket object, and wake up any suspended
 * operations that are affected by this.
 */
void
sockevent_set_error(struct sock * sock, int err)
{

        assert(err < 0);
        assert(sock->sock_ops != NULL);

        /* If an error was set already, it will be overridden. */
        sock->sock_err = err;

        sockevent_raise(sock, SEV_BIND | SEV_CONNECT | SEV_SEND | SEV_RECV);
}

/*
 * Initialize timer-related data structures.
 */
static void
socktimer_init(void)
{

        SLIST_INIT(&socktimer);

        init_timer(&sockevent_timer);
}

/*
 * Check whether the given socket object has any suspended requests that have
 * now expired.  If so, cancel them.  Also, if the socket object has any
 * suspended requests with a timeout that has not yet expired, return the
 * earliest (relative) timeout of all of them, or TMR_NEVER if no such requests
 * are present.
 */
static clock_t
sockevent_expire(struct sock * sock, clock_t now)
{
        struct sockevent_proc *spr, **sprp;
        clock_t lowest, left;
        int r;

        /*
         * First handle the case that the socket is closed.  In this case,
         * there may be a linger timer, although the socket may also simply
         * still be on the timer list because of a request that did not time
         * out right before the socket was closed.
         */
        if (sock->sock_flags & SFL_CLOSING) {
                /* Was there a linger timer and has it expired? */
                if ((sock->sock_opt & SO_LINGER) &&
                    tmr_is_first(sock->sock_linger, now)) {
                        assert(sock->sock_ops->sop_close != NULL);

                        /*
                         * Whatever happens next, we must now resume the
                         * pending close operation, if it was not canceled
                         * earlier.  As before, we return OK rather than the
                         * standardized EWOULDBLOCK, to ensure that the user
                         * process knows the file descriptor has been closed.
                         */
                        if ((spr = sock->sock_proc) != NULL) {
                                assert(spr->spr_event == SEV_CLOSE);
                                assert(spr->spr_next == NULL);

                                sock->sock_proc = NULL;

                                sockdriver_reply_generic(&spr->spr_call, OK);

                                sockevent_proc_free(spr);
                        }

                        /*
                         * Tell the socket driver that closing the socket is
                         * now a bit more desired than the last time we asked.
                         */
                        r = sock->sock_ops->sop_close(sock, TRUE /*force*/);

                        assert(r == OK || r == SUSPEND);

                        /*
                         * The linger timer fires once.  After that, the socket
                         * driver is free to decide that it still will not
                         * close the socket.  If it does, do not fire the
                         * linger timer again.
                         */
                        if (r == SUSPEND)
                                sock->sock_opt &= ~SO_LINGER;
                        else
                                sockevent_free(sock);
                }

                return TMR_NEVER;
        }

        /*
         * Then see if any send and/or receive requests have expired.  Also see
         * if there are any send and/or receive requests left that have not yet
         * expired but do have a timeout, so that we can return the lowest of
         * those timeouts.
         */
        lowest = TMR_NEVER;

        for (sprp = &sock->sock_proc; (spr = *sprp) != NULL; ) {
                /* Skip requests without a timeout. */
                if (spr->spr_timer == 0) {
                        sprp = &spr->spr_next;

                        continue;
                }

                assert(spr->spr_event == SEV_SEND ||
                    spr->spr_event == SEV_RECV);

                /*
                 * If the request has expired, cancel it and remove it from the
                 * list.  Otherwise, see if the request has the lowest number
                 * of ticks until its timeout so far.
                 */
                if (tmr_is_first(spr->spr_time, now)) {
                        *sprp = spr->spr_next;

                        if (spr->spr_event == SEV_SEND)
                                sockevent_cancel_send(sock, spr, EWOULDBLOCK);
                        else
                                sockevent_cancel_recv(sock, spr, EWOULDBLOCK);

                        sockevent_proc_free(spr);
                } else {
                        left = spr->spr_time - now;

                        if (lowest == TMR_NEVER || lowest > left)
                                lowest = left;

                        sprp = &spr->spr_next;
                }
        }

        return lowest;
}

/*
 * The socket event alarm went off.  Go through the set of socket objects with
 * timers, and see if any of their requests have now expired.  Set a new alarm
 * as necessary.
 */
static void
socktimer_expire(int arg __unused)
{
        SLIST_HEAD(, sock) oldtimer;
        struct sock *sock, *tsock;
        clock_t now, lowest, left;
        int working;

        /*
         * This function may or may not be called from a context where we are
         * already deferring events, so we have to cover both cases here.
         */
        if ((working = sockevent_working) == FALSE)
                sockevent_working = TRUE;

        /* Start a new list. */
        memcpy(&oldtimer, &socktimer, sizeof(oldtimer));
        SLIST_INIT(&socktimer);

        now = getticks();
        lowest = TMR_NEVER;

        /*
         * Go through all sockets that have or had a request with a timeout,
         * canceling any expired requests and building a new list of sockets
         * that still have requests with timeouts as we go.
         */
        SLIST_FOREACH_SAFE(sock, &oldtimer, sock_timer, tsock) {
                assert(sock->sock_flags & SFL_TIMER);
                sock->sock_flags &= ~SFL_TIMER;

                left = sockevent_expire(sock, now);
                /*
                 * The sock object may already have been deallocated now.
                 * If 'next' is TMR_NEVER, do not touch 'sock' anymore.
                 */

                if (left != TMR_NEVER) {
                        if (lowest == TMR_NEVER || lowest > left)
                                lowest = left;

                        SLIST_INSERT_HEAD(&socktimer, sock, sock_timer);

                        sock->sock_flags |= SFL_TIMER;
                }
        }

        /* If there is a new lowest timeout at all, set a new timer. */
        if (lowest != TMR_NEVER)
                set_timer(&sockevent_timer, lowest, socktimer_expire, 0);

        if (!working) {
                /* If any new events were raised, process them now. */
                if (sockevent_has_events())
                        sockevent_pump();

                sockevent_working = FALSE;
        }
}

/*
 * Set a timer for the given (relative) number of clock ticks, adding the
 * associated socket object to the set of socket objects with timers, if it was
 * not already in that set.  Set a new alarm if necessary, and return the
 * absolute timeout for the timer.  Since the timers list is maintained lazily,
 * the caller need not take the object off the set if the call was canceled
 * later; see also socktimer_del().
 */
static clock_t
socktimer_add(struct sock * sock, clock_t ticks)
{
        clock_t now;

        /*
         * Relative time comparisons require that any two times are no more
         * than half the comparison space (clock_t, unsigned long) apart.
         */
        assert(ticks <= TMRDIFF_MAX);

        /* If the socket was not already on the timers list, put it on. */
        if (!(sock->sock_flags & SFL_TIMER)) {
                SLIST_INSERT_HEAD(&socktimer, sock, sock_timer);

                sock->sock_flags |= SFL_TIMER;
        }

        /*
         * (Re)set the timer if either it was not running at all or this new
         * timeout will occur sooner than the currently scheduled alarm.  Note
         * that setting a timer that was already set is allowed.
         */
        now = getticks();

        if (!tmr_is_set(&sockevent_timer) ||
            tmr_is_first(now + ticks, tmr_exp_time(&sockevent_timer)))
                set_timer(&sockevent_timer, ticks, socktimer_expire, 0);

        /* Return the absolute timeout. */
        return now + ticks;
}

/*
 * Remove a socket object from the set of socket objects with timers.  Since
 * the timer list is maintained lazily, this needs to be done only right before
 * the socket object is freed.
 */
static void
socktimer_del(struct sock * sock)
{

        if (sock->sock_flags & SFL_TIMER) {
                /* This macro is O(n). */
                SLIST_REMOVE(&socktimer, sock, sock, sock_timer);

                sock->sock_flags &= ~SFL_TIMER;
        }
}

/*
 * Bind a socket to a local address.
 */
static int
sockevent_bind(sockid_t id, const struct sockaddr * __restrict addr,
        socklen_t addr_len, endpoint_t user_endpt,
        const struct sockdriver_call * __restrict call)
{
        struct sock *sock;
        int r;

        if ((sock = sockhash_get(id)) == NULL)
                return EINVAL;

        if (sock->sock_ops->sop_bind == NULL)
                return EOPNOTSUPP;

        /* Binding a socket in listening mode is never supported. */
        if (sock->sock_opt & SO_ACCEPTCONN)
                return EINVAL;

        r = sock->sock_ops->sop_bind(sock, addr, addr_len, user_endpt);

        if (r == SUSPEND) {
                if (call == NULL)
                        return EINPROGRESS;

                sockevent_suspend(sock, SEV_BIND, call, user_endpt);
        }

        return r;
}

/*
 * Connect a socket to a remote address.
 */
static int
sockevent_connect(sockid_t id, const struct sockaddr * __restrict addr,
        socklen_t addr_len, endpoint_t user_endpt,
        const struct sockdriver_call * call)
{
        struct sockdriver_call fakecall;
        struct sockevent_proc *spr;
        struct sock *sock;
        int r;

        if ((sock = sockhash_get(id)) == NULL)
                return EINVAL;

        if (sock->sock_ops->sop_connect == NULL)
                return EOPNOTSUPP;

        /* Connecting a socket in listening mode is never supported. */
        if (sock->sock_opt & SO_ACCEPTCONN)
                return EOPNOTSUPP;

        /*
         * The upcoming connect call may fire an accept event for which the
         * handler may in turn fire a connect event on this socket.  Since we
         * delay event processing until after processing calls, this would
         * create the problem that even if the connection is accepted right
         * away, non-blocking connect requests would return EINPROGRESS.  For
         * UDS, this is undesirable behavior.  To remedy this, we use a hack:
         * we temporarily suspend the connect even if non-blocking, then
         * process events, and then cancel the connect request again.  If the
         * connection was accepted immediately, the cancellation will have no
         * effect, since the request has already been replied to.  In order not
         * to violate libsockdriver rules with this hack, we fabricate a fake
         * 'conn' object.
         */
        r = sock->sock_ops->sop_connect(sock, addr, addr_len, user_endpt);

        if (r == SUSPEND) {
                if (call != NULL || sockevent_has_events()) {
                        if (call == NULL) {
                                fakecall.sc_endpt = NONE;

                                call = &fakecall;
                        }

                        assert(!sockevent_has_suspended(sock,
                            SEV_SEND | SEV_RECV));

                        sockevent_suspend(sock, SEV_CONNECT, call, user_endpt);

                        if (call == &fakecall) {
                                /* Process any pending events first now. */
                                sockevent_pump();

                                /*
                                 * If the connect request has not been resumed
                                 * yet now, we must remove it from the queue
                                 * again, and return EINPROGRESS ourselves.
                                 * Otherwise, return OK or a pending error.
                                 */
                                spr = sockevent_unsuspend(sock, call);
                                if (spr != NULL) {
                                        sockevent_proc_free(spr);

                                        r = EINPROGRESS;
                                } else if ((r = sock->sock_err) != OK)
                                        sock->sock_err = OK;
                        }
                } else
                        r = EINPROGRESS;
        }

        if (r == OK) {
                /*
                 * A completed connection attempt also always implies that the
                 * socket becomes writable.  For convenience we enforce this
                 * rule here, because it is easy to forget.
                 */
                sockevent_raise(sock, SEV_SEND);
        }

        return r;
}

/*
 * Put a socket in listening mode.
 */
static int
sockevent_listen(sockid_t id, int backlog)
{
        struct sock *sock;
        int r;

        if ((sock = sockhash_get(id)) == NULL)
                return EINVAL;

        if (sock->sock_ops->sop_listen == NULL)
                return EOPNOTSUPP;

        /*
         * Perform a general adjustment on the backlog value, applying the
         * customary BSD "fudge factor" of 1.5x.  Keep the value within bounds
         * though.  POSIX imposes that a negative backlog value is equal to a
         * backlog value of zero.  A backlog value of zero, in turn, may mean
         * anything; we take it to be one.  POSIX also imposes that all socket
         * drivers accept up to at least SOMAXCONN connections on the queue.
         */
        if (backlog < 0)
                backlog = 0;
        if (backlog < SOMAXCONN)
                backlog += 1 + ((unsigned int)backlog >> 1);
        if (backlog > SOMAXCONN)
                backlog = SOMAXCONN;

        r = sock->sock_ops->sop_listen(sock, backlog);

        /*
         * On success, the socket is now in listening mode.  As part of that,
         * a select(2) ready-to-read condition now indicates that a connection
         * may be accepted on the socket, rather than that data may be read.
         * Since libsockevent is responsible for this distinction, we keep
         * track of the listening mode at this level.  Conveniently, there is a
         * socket option for this, which we support out of the box as a result.
         */
        if (r == OK) {
                sock->sock_opt |= SO_ACCEPTCONN;

                /*
                 * For the extremely unlikely case that right after the socket
                 * is put into listening mode, it has a connection ready to
                 * accept, we retest blocked ready-to-read select queries now.
                 */
                sockevent_raise(sock, SEV_ACCEPT);
        }

        return r;
}

/*
 * Accept a connection on a listening socket, creating a new socket.
 */
static sockid_t
sockevent_accept(sockid_t id, struct sockaddr * __restrict addr,
        socklen_t * __restrict addr_len, endpoint_t user_endpt,
        const struct sockdriver_call * __restrict call)
{
        struct sock *sock, *newsock;
        sockid_t r;

        if ((sock = sockhash_get(id)) == NULL)
                return EINVAL;

        if (sock->sock_ops->sop_accept == NULL)
                return EOPNOTSUPP;

        /*
         * Attempt to accept a connection.  The socket driver is responsible
         * for allocating a sock object (and identifier) on success.  It may
         * already have done so before, in which case it should leave newsock
         * filled with NULL; otherwise, the returned sock object is cloned from
         * the listening socket.  The socket driver is also responsible for
         * failing the call if the socket is not in listening mode, because it
         * must specify the error to return: EOPNOTSUPP or EINVAL.
         */
        newsock = NULL;

        if ((r = sock->sock_ops->sop_accept(sock, addr, addr_len, user_endpt,
            &newsock)) == SUSPEND) {
                assert(sock->sock_opt & SO_ACCEPTCONN);

                if (call == NULL)
                        return EWOULDBLOCK;

                sockevent_suspend(sock, SEV_ACCEPT, call, user_endpt);

                return SUSPEND;
        }

        if (r >= 0)
                sockevent_accepted(sock, newsock, r);

        return r;
}

/*
 * Send regular and/or control data.
 */
static int
sockevent_send(sockid_t id, const struct sockdriver_data * __restrict data,
        size_t len, const struct sockdriver_data * __restrict ctl_data,
        socklen_t ctl_len, const struct sockaddr * __restrict addr,
        socklen_t addr_len, endpoint_t user_endpt, int flags,
        const struct sockdriver_call * __restrict call)
{
        struct sock *sock;
        clock_t time;
        size_t min, off;
        socklen_t ctl_off;
        int r, timer;

        if ((sock = sockhash_get(id)) == NULL)
                return EINVAL;

        /*
         * The order of the following checks is not necessarily fixed, and may
         * be changed later.  As far as applicable, they should match the order
         * of the checks during call resumption, though.
         */
        if ((r = sock->sock_err) != OK) {
                sock->sock_err = OK;

                return r;
        }

        if (sock->sock_flags & SFL_SHUT_WR) {
                sockevent_sigpipe(sock, user_endpt, flags);

                return EPIPE;
        }

        /*
         * Translate the sticky SO_DONTROUTE option to a per-request
         * MSG_DONTROUTE flag.  This achieves two purposes: socket drivers have
         * to check only one flag, and socket drivers that do not support the
         * flag will fail send requests in a consistent way.
         */
        if (sock->sock_opt & SO_DONTROUTE)
                flags |= MSG_DONTROUTE;

        /*
         * Check if this is a valid send request as far as the socket driver is
         * concerned.  We do this separately from sop_send for the reason that
         * this send request may immediately be queued behind other pending
         * send requests (without a call to sop_send), which means even invalid
         * requests would be queued and not return failure until much later.
         */
        if (sock->sock_ops->sop_pre_send != NULL &&
            (r = sock->sock_ops->sop_pre_send(sock, len, ctl_len, addr,
            addr_len, user_endpt,
            flags & ~(MSG_DONTWAIT | MSG_NOSIGNAL))) != OK)
                return r;

        if (sock->sock_ops->sop_send == NULL)
                return EOPNOTSUPP;

        off = 0;
        ctl_off = 0;

        /*
         * Sending out-of-band data is treated differently from regular data:
         *
         * - sop_send is called immediately, even if a partial non-OOB send
         *   operation is currently suspended (TODO: it may have to be aborted
         *   in order to maintain atomicity guarantees - that should be easy);
         * - sop_send must not return SUSPEND; instead, if it cannot process
         *   the OOB data immediately, it must return an appropriate error;
         * - the send low watermark is ignored.
         *
         * Given that none of the current socket drivers support OOB data at
         * all, more sophisticated approaches would have no added value now.
         */
        if (flags & MSG_OOB) {
                r = sock->sock_ops->sop_send(sock, data, len, &off, ctl_data,
                    ctl_len, &ctl_off, addr, addr_len, user_endpt, flags, 0);

                if (r == SUSPEND)
                        panic("libsockevent: MSG_OOB send calls may not be "
                            "suspended");

                return (r == OK) ? (int)off : r;
        }

        /*
         * Only call the actual sop_send function now if no other send calls
         * are suspended already.
         *
         * Call sop_send with 'min' set to the minimum of the request size and
         * the socket's send low water mark, but only if the call is non-
         * blocking.  For stream-oriented sockets, this should have the effect
         * that non-blocking calls fail with EWOULDBLOCK if not at least that
         * much can be sent immediately. For consistency, we choose to apply
         * the same threshold to blocking calls.  For datagram-oriented
         * sockets, the minimum is not a factor to be considered.
         */
        if (!sockevent_has_suspended(sock, SEV_SEND)) {
                min = sock->sock_slowat;
                if (min > len)
                        min = len;

                r = sock->sock_ops->sop_send(sock, data, len, &off, ctl_data,
                    ctl_len, &ctl_off, addr, addr_len, user_endpt, flags, min);
        } else
                r = SUSPEND;

        if (r == SUSPEND) {
                /*
                 * We do not store the target's address on suspension, because
                 * that would add significantly to the per-process suspension
                 * state.  As a result, we disallow socket drivers from
                 * suspending send calls with addresses, because we would no
                 * longer have the address for proper call resumption.
                 * However, we do not know here whether the socket is in
                 * connection-oriented mode; if it is, the address is to be
                 * ignored altogether.  Therefore, there is no test on 'addr'
                 * here.  Resumed calls will get a NULL address pointer, and
                 * the socket driver is expected to do the right thing.
                 */

                /*
                 * For non-blocking socket calls, return an error only if we
                 * were not able to send anything at all.  If only control data
                 * were sent, the return value is therefore zero.
                 */
                if (call != NULL) {
                        if (sock->sock_stimeo != 0) {
                                timer = TRUE;
                                time = socktimer_add(sock, sock->sock_stimeo);
                        } else {
                                timer = FALSE;
                                time = 0;
                        }

                        sockevent_suspend_data(sock, SEV_SEND, timer, call,
                            user_endpt, data, len, off, ctl_data, ctl_len,
                            ctl_off, flags, 0, time);
                } else
                        r = (off > 0 || ctl_off > 0) ? OK : EWOULDBLOCK;
        } else if (r == EPIPE)
                sockevent_sigpipe(sock, user_endpt, flags);

        return (r == OK) ? (int)off : r;
}

/*
 * The inner part of the receive request handler.  An error returned from here
 * may be overridden by an error pending on the socket, although data returned
 * from here trumps such pending errors.
 */
static int
sockevent_recv_inner(struct sock * sock,
        const struct sockdriver_data * __restrict data,
        size_t len, size_t * __restrict off,
        const struct sockdriver_data * __restrict ctl_data,
        socklen_t ctl_len, socklen_t * __restrict ctl_off,
        struct sockaddr * __restrict addr,
        socklen_t * __restrict addr_len, endpoint_t user_endpt,
        int * __restrict flags, const struct sockdriver_call * __restrict call)
{
        clock_t time;
        size_t min;
        int r, oob, inflags, timer;

        /*
         * Check if this is a valid receive request as far as the socket driver
         * is concerned.  We do this separately from sop_recv for the reason
         * that this receive request may immediately be queued behind other
         * pending receive requests (without a call to sop_recv), which means
         * even invalid requests would be queued and not return failure until
         * much later.
         */
        inflags = *flags;
        *flags = 0;

        if (sock->sock_ops->sop_pre_recv != NULL &&
            (r = sock->sock_ops->sop_pre_recv(sock, user_endpt,
            inflags & ~(MSG_DONTWAIT | MSG_NOSIGNAL))) != OK)
                return r;

        /*
         * The order of the following checks is not necessarily fixed, and may
         * be changed later.  As far as applicable, they should match the order
         * of the checks during call resumption, though.
         */
        if (sock->sock_flags & SFL_SHUT_RD)
                return SOCKEVENT_EOF;

        if (sock->sock_ops->sop_recv == NULL)
                return EOPNOTSUPP;

        /*
         * Receiving out-of-band data is treated differently from regular data:
         *
         * - sop_recv is called immediately, even if a partial non-OOB receive
         *   operation is currently suspended (TODO: it may have to be aborted
         *   in order to maintain atomicity guarantees - that should be easy);
         * - sop_recv must not return SUSPEND; instead, if it cannot return any
         *   the OOB data immediately, it must return an appropriate error;
         * - the receive low watermark is ignored.
         *
         * Given that none of the current socket drivers support OOB data at
         * all, more sophisticated approaches would have no added value now.
         */
        oob = (inflags & MSG_OOB);

        if (oob && (sock->sock_opt & SO_OOBINLINE))
                return EINVAL;

        /*
         * Only call the actual sop_recv function now if no other receive
         * calls are suspended already.
         *
         * Call sop_recv with 'min' set to the minimum of the request size and
         * the socket's socket's low water mark, unless there is a pending
         * error.  As a result, blocking calls will block, and non-blocking
         * calls will yield EWOULDBLOCK, if at least that much can be received,
         * unless another condition (EOF or that pending error) prevents more
         * from being received anyway.  For datagram-oriented sockets, the
         * minimum is not a factor to be considered.
         */
        if (oob || !sockevent_has_suspended(sock, SEV_RECV)) {
                if (!oob && sock->sock_err == OK) {
                        min = sock->sock_rlowat;
                        if (min > len)
                                min = len;
                } else
                        min = 0; /* receive even no-data segments */

                r = sock->sock_ops->sop_recv(sock, data, len, off, ctl_data,
                    ctl_len, ctl_off, addr, addr_len, user_endpt, inflags, min,
                    flags);
        } else
                r = SUSPEND;

        assert(r <= 0 || r == SOCKEVENT_EOF);

        if (r == SUSPEND) {
                if (oob)
                        panic("libsockevent: MSG_OOB receive calls may not be "
                            "suspended");

                /*
                 * For non-blocking socket calls, return EWOULDBLOCK only if we
                 * did not receive anything at all.  If only control data were
                 * received, the return value is therefore zero.  Suspension
                 * implies that there is nothing to read.  For the purpose of
                 * the calling wrapper function, never suspend a call when
                 * there is a pending error.
                 */
                if (call != NULL && sock->sock_err == OK) {
                        if (sock->sock_rtimeo != 0) {
                                timer = TRUE;
                                time = socktimer_add(sock, sock->sock_rtimeo);
                        } else {
                                timer = FALSE;
                                time = 0;
                        }

                        sockevent_suspend_data(sock, SEV_RECV, timer, call,
                            user_endpt, data, len, *off, ctl_data,
                            ctl_len, *ctl_off, inflags, *flags, time);
                } else
                        r = EWOULDBLOCK;
        }

        return r;
}

/*
 * Receive regular and/or control data.
 */
static int
sockevent_recv(sockid_t id, const struct sockdriver_data * __restrict data,
        size_t len, const struct sockdriver_data * __restrict ctl_data,
        socklen_t * __restrict ctl_len, struct sockaddr * __restrict addr,
        socklen_t * __restrict addr_len, endpoint_t user_endpt,
        int * __restrict flags, const struct sockdriver_call * __restrict call)
{
        struct sock *sock;
        size_t off;
        socklen_t ctl_inlen;
        int r;

        if ((sock = sockhash_get(id)) == NULL)
                return EINVAL;

        /*
         * This function is a wrapper around the actual receive functionality.
         * The reason for this is that receiving data should take precedence
         * over a pending socket error, while a pending socket error should
         * take precedence over both regular errors as well as EOF.  In other
         * words: if there is a pending error, we must try to receive anything
         * at all; if receiving does not work, we must fail the call with the
         * pending error.  However, until we call the receive callback, we have
         * no way of telling whether any data can be received.  So we must try
         * that before we can decide whether to return a pending error.
         */
        off = 0;
        ctl_inlen = *ctl_len;
        *ctl_len = 0;

        /*
         * Attempt to perform the actual receive call.
         */
        r = sockevent_recv_inner(sock, data, len, &off, ctl_data, ctl_inlen,
            ctl_len, addr, addr_len, user_endpt, flags, call);

        /*
         * If the receive request succeeded, or it failed but yielded a partial
         * result, then return the (partal) result.  Otherwise, if an error is
         * pending, return that error.  Otherwise, return either a regular
         * error or 0 for EOF.
         */
        if (r == OK || (r != SUSPEND && (off > 0 || *ctl_len > 0)))
                r = (int)off;
        else if (sock->sock_err != OK) {
                assert(r != SUSPEND);

                r = sock->sock_err;

                sock->sock_err = OK;
        } else if (r == SOCKEVENT_EOF)
                r = 0;

        return r;
}

/*
 * Process an I/O control call.
 */
static int
sockevent_ioctl(sockid_t id, unsigned long request,
        const struct sockdriver_data * __restrict data, endpoint_t user_endpt,
        const struct sockdriver_call * __restrict call __unused)
{
        struct sock *sock;
        size_t size;
        int r, val;

        if ((sock = sockhash_get(id)) == NULL)
                return EINVAL;

        /* We handle a very small subset of generic IOCTLs here. */
        switch (request) {
        case FIONREAD:
                size = 0;
                if (!(sock->sock_flags & SFL_SHUT_RD) &&
                    sock->sock_ops->sop_test_recv != NULL)
                        (void)sock->sock_ops->sop_test_recv(sock, 0, &size);

                val = (int)size;

                return sockdriver_copyout(data, 0, &val, sizeof(val));
        }

        if (sock->sock_ops->sop_ioctl == NULL)
                return ENOTTY;

        r = sock->sock_ops->sop_ioctl(sock, request, data, user_endpt);

        /*
         * Suspending IOCTL requests is not currently supported by this
         * library, even though the VFS protocol and libsockdriver do support
         * it.  The reason is that IOCTLs do not match our proces suspension
         * model: they could be neither queued nor repeated.  For now, it seems
         * that this feature is not needed by the socket drivers either.  Thus,
         * even though there are possible solutions, we defer implementing them
         * until we know what exactly is needed.
         */
        if (r == SUSPEND)
                panic("libsockevent: socket driver suspended IOCTL 0x%lx",
                    request);

        return r;
}

/*
 * Set socket options.
 */
static int
sockevent_setsockopt(sockid_t id, int level, int name,
        const struct sockdriver_data * data, socklen_t len)
{
        struct sock *sock;
        struct linger linger;
        struct timeval tv;
        clock_t secs, ticks;
        int r, val;

        if ((sock = sockhash_get(id)) == NULL)
                return EINVAL;

        if (level == SOL_SOCKET) {
                /*
                 * Handle a subset of the socket-level options here.  For most
                 * of them, this means that the socket driver itself need not
                 * handle changing or returning the options, but still needs to
                 * implement the correct behavior based on them where needed.
                 * A few of them are handled exclusively in this library:
                 * SO_ACCEPTCONN, SO_NOSIGPIPE, SO_ERROR, SO_TYPE, SO_LINGER,
                 * SO_SNDLOWAT, SO_RCVLOWAT, SO_SNDTIMEO, and SO_RCVTIMEO.
                 * The SO_USELOOPBACK option is explicitly absent, as it is
                 * valid for routing sockets only and is set by default there.
                 */
                switch (name) {
                case SO_DEBUG:
                case SO_REUSEADDR:
                case SO_KEEPALIVE:
                case SO_DONTROUTE:
                case SO_BROADCAST:
                case SO_OOBINLINE:
                case SO_REUSEPORT:
                case SO_NOSIGPIPE:
                case SO_TIMESTAMP:
                        /*
                         * Simple on-off options.  Changing them does not
                         * involve the socket driver.
                         */
                        if ((r = sockdriver_copyin_opt(data, &val, sizeof(val),
                            len)) != OK)
                                return r;

                        if (val)
                                sock->sock_opt |= (unsigned int)name;
                        else
                                sock->sock_opt &= ~(unsigned int)name;

                        /*
                         * In priciple these on-off options are maintained in
                         * this library, but some socket drivers may need to
                         * apply the options elsewhere, so we notify them that
                         * something has changed.  Using the sop_setsockopt
                         * callback would be inconvenient for this for two
                         * reasons: multiple value copy-ins and default errors.
                         */
                        if (sock->sock_ops->sop_setsockmask != NULL)
                                sock->sock_ops->sop_setsockmask(sock,
                                    sock->sock_opt);

                        /*
                         * The inlining of OOB data may make new data available
                         * through regular receive calls.  Thus, see if we can
                         * wake up any suspended receive calls now.
                         */
                        if (name == SO_OOBINLINE && val)
                                sockevent_raise(sock, SEV_RECV);

                        return OK;

                case SO_LINGER:
                        /* The only on-off option with an associated value. */
                        if ((r = sockdriver_copyin_opt(data, &linger,
                            sizeof(linger), len)) != OK)
                                return r;

                        if (linger.l_onoff) {
                                if (linger.l_linger < 0)
                                        return EINVAL;
                                /* EDOM is the closest applicable error.. */
                                secs = (clock_t)linger.l_linger;
                                if (secs >= TMRDIFF_MAX / sys_hz())
                                        return EDOM;

                                sock->sock_opt |= SO_LINGER;
                                sock->sock_linger = secs * sys_hz();
                        } else {
                                sock->sock_opt &= ~SO_LINGER;
                                sock->sock_linger = 0;
                        }

                        return OK;

                case SO_SNDLOWAT:
                case SO_RCVLOWAT:
                        if ((r = sockdriver_copyin_opt(data, &val, sizeof(val),
                            len)) != OK)
                                return r;

                        if (val <= 0)
                                return EINVAL;

                        /*
                         * Setting these values may allow suspended operations
                         * (send, recv, select) to be resumed, so recheck.
                         */
                        if (name == SO_SNDLOWAT) {
                                sock->sock_slowat = (size_t)val;

                                sockevent_raise(sock, SEV_SEND);
                        } else {
                                sock->sock_rlowat = (size_t)val;

                                sockevent_raise(sock, SEV_RECV);
                        }

                        return OK;

                case SO_SNDTIMEO:
                case SO_RCVTIMEO:
                        if ((r = sockdriver_copyin_opt(data, &tv, sizeof(tv),
                            len)) != OK)
                                return r;

                        if (tv.tv_sec < 0 || tv.tv_usec < 0 ||
                            (unsigned long)tv.tv_usec >= US)
                                return EINVAL;
                        if (tv.tv_sec >= TMRDIFF_MAX / sys_hz())
                                return EDOM;

                        ticks = tv.tv_sec * sys_hz() +
                            (tv.tv_usec * sys_hz() + US - 1) / US;

                        if (name == SO_SNDTIMEO)
                                sock->sock_stimeo = ticks;
                        else
                                sock->sock_rtimeo = ticks;

                        /*
                         * The timeouts for any calls already in progress for
                         * this socket are left as is.
                         */
                        return OK;

                case SO_ACCEPTCONN:
                case SO_ERROR:
                case SO_TYPE:
                        /* These options may be retrieved but not set. */
                        return ENOPROTOOPT;

                default:
                        /*
                         * The remaining options either cannot be handled in a
                         * generic way, or are not recognized altogether.  Pass
                         * them to the socket driver, which should handle what
                         * it knows and reject the rest.
                         */
                        break;
                }
        }

        if (sock->sock_ops->sop_setsockopt == NULL)
                return ENOPROTOOPT;

        /*
         * The socket driver must return ENOPROTOOPT for all options it does
         * not recognize.
         */
        return sock->sock_ops->sop_setsockopt(sock, level, name, data, len);
}

/*
 * Retrieve socket options.
 */
static int
sockevent_getsockopt(sockid_t id, int level, int name,
        const struct sockdriver_data * __restrict data,
        socklen_t * __restrict len)
{
        struct sock *sock;
        struct linger linger;
        struct timeval tv;
        clock_t ticks;
        int val;

        if ((sock = sockhash_get(id)) == NULL)
                return EINVAL;

        if (level == SOL_SOCKET) {
                /*
                 * As with setting, handle a subset of the socket-level options
                 * here.  The rest is to be taken care of by the socket driver.
                 */
                switch (name) {
                case SO_DEBUG:
                case SO_ACCEPTCONN:
                case SO_REUSEADDR:
                case SO_KEEPALIVE:
                case SO_DONTROUTE:
                case SO_BROADCAST:
                case SO_OOBINLINE:
                case SO_REUSEPORT:
                case SO_NOSIGPIPE:
                case SO_TIMESTAMP:
                        val = !!(sock->sock_opt & (unsigned int)name);

                        return sockdriver_copyout_opt(data, &val, sizeof(val),
                            len);

                case SO_LINGER:
                        linger.l_onoff = !!(sock->sock_opt & SO_LINGER);
                        linger.l_linger = sock->sock_linger / sys_hz();

                        return sockdriver_copyout_opt(data, &linger,
                           sizeof(linger), len);

                case SO_ERROR:
                        if ((val = -sock->sock_err) != OK)
                                sock->sock_err = OK;

                        return sockdriver_copyout_opt(data, &val, sizeof(val),
                            len);

                case SO_TYPE:
                        val = sock->sock_type;

                        return sockdriver_copyout_opt(data, &val, sizeof(val),
                            len);

                case SO_SNDLOWAT:
                        val = (int)sock->sock_slowat;

                        return sockdriver_copyout_opt(data, &val, sizeof(val),
                            len);

                case SO_RCVLOWAT:
                        val = (int)sock->sock_rlowat;

                        return sockdriver_copyout_opt(data, &val, sizeof(val),
                            len);

                case SO_SNDTIMEO:
                case SO_RCVTIMEO:
                        if (name == SO_SNDTIMEO)
                                ticks = sock->sock_stimeo;
                        else
                                ticks = sock->sock_rtimeo;

                        tv.tv_sec = ticks / sys_hz();
                        tv.tv_usec = (ticks % sys_hz()) * US / sys_hz();

                        return sockdriver_copyout_opt(data, &tv, sizeof(tv),
                            len);

                default:
                        break;
                }
        }

        if (sock->sock_ops->sop_getsockopt == NULL)
                return ENOPROTOOPT;

        /*
         * The socket driver must return ENOPROTOOPT for all options it does
         * not recognize.
         */
        return sock->sock_ops->sop_getsockopt(sock, level, name, data, len);
}

/*
 * Retrieve a socket's local address.
 */
static int
sockevent_getsockname(sockid_t id, struct sockaddr * __restrict addr,
        socklen_t * __restrict addr_len)
{
        struct sock *sock;

        if ((sock = sockhash_get(id)) == NULL)
                return EINVAL;

        if (sock->sock_ops->sop_getsockname == NULL)
                return EOPNOTSUPP;

        return sock->sock_ops->sop_getsockname(sock, addr, addr_len);
}

/*
 * Retrieve a socket's remote address.
 */
static int
sockevent_getpeername(sockid_t id, struct sockaddr * __restrict addr,
        socklen_t * __restrict addr_len)
{
        struct sock *sock;

        if ((sock = sockhash_get(id)) == NULL)
                return EINVAL;

        /* Listening-mode sockets cannot possibly have a peer address. */
        if (sock->sock_opt & SO_ACCEPTCONN)
                return ENOTCONN;

        if (sock->sock_ops->sop_getpeername == NULL)
                return EOPNOTSUPP;

        return sock->sock_ops->sop_getpeername(sock, addr, addr_len);
}

/*
 * Mark the socket object as shut down for sending and/or receiving.  The flags
 * parameter may be a bitwise-OR'ed combination of SFL_SHUT_RD and SFL_SHUT_WR.
 * This function will wake up any suspended requests affected by this change,
 * but it will not invoke the sop_shutdown() callback function on the socket.
 * The function may in fact be called from sop_shutdown() before completion to
 * mark the socket as shut down as reflected by sockevent_is_shutdown().
 */
void
sockevent_set_shutdown(struct sock * sock, unsigned int flags)
{
        unsigned int mask;

        assert(sock->sock_ops != NULL);
        assert(!(flags & ~(SFL_SHUT_RD | SFL_SHUT_WR)));

        /* Look at the newly set flags only. */
        flags &= ~(unsigned int)sock->sock_flags;

        if (flags != 0) {
                sock->sock_flags |= flags;

                /*
                 * Wake up any blocked calls that are affected by the shutdown.
                 * Shutting down listening sockets causes ongoing accept calls
                 * to be rechecked.
                 */
                mask = 0;
                if (flags & SFL_SHUT_RD)
                        mask |= SEV_RECV;
                if (flags & SFL_SHUT_WR)
                        mask |= SEV_SEND;
                if (sock->sock_opt & SO_ACCEPTCONN)
                        mask |= SEV_ACCEPT;

                assert(mask != 0);
                sockevent_raise(sock, mask);
        }
}

/*
 * Shut down socket send and receive operations.
 */
static int
sockevent_shutdown(sockid_t id, int how)
{
        struct sock *sock;
        unsigned int flags;
        int r;

        if ((sock = sockhash_get(id)) == NULL)
                return EINVAL;

        /* Convert the request to a set of flags. */
        flags = 0;
        if (how == SHUT_RD || how == SHUT_RDWR)
                flags |= SFL_SHUT_RD;
        if (how == SHUT_WR || how == SHUT_RDWR)
                flags |= SFL_SHUT_WR;

        if (sock->sock_ops->sop_shutdown != NULL)
                r = sock->sock_ops->sop_shutdown(sock, flags);
        else
                r = OK;

        /* On success, update our internal state as well. */
        if (r == OK)
                sockevent_set_shutdown(sock, flags);

        return r;
}

/*
 * Close a socket.
 */
static int
sockevent_close(sockid_t id, const struct sockdriver_call * call)
{
        struct sock *sock;
        int r, force;

        if ((sock = sockhash_get(id)) == NULL)
                return EINVAL;

        assert(sock->sock_proc == NULL);
        sock->sock_select.ss_endpt = NONE;

        /*
         * There are several scenarios when it comes to closing sockets.  First
         * of all, we never actually force the socket driver to close a socket.
         * The driver may always suspend the close call and take as long as it
         * wants.  After a suspension, it signals its completion of the close
         * through the SEV_CLOSE socket event.
         *
         * With that said, we offer two levels of urgency regarding the close
         * request: regular and forced.  The former allows for a graceful
         * close; the latter urges the socket driver to close the socket as
         * soon as possible.  A socket that has been requested to be closed
         * gracefully can, as long as it is still open (i.e., no SEV_CLOSE was
         * fired yet), later be requested to be closed forcefully.  This is how
         * SO_LINGER with a nonzero timeout is implemented.  If SO_LINGER is
         * set with a zero timeout, the socket is force-closed immediately.
         * Finally, if SO_LINGER is not set, the socket will be closed normally
         * and never be forced--akin to SO_LINGER with an infinite timeout.
         *
         * The return value of the caller's close(2) may only ever be either
         * OK or EINPROGRESS, to ensure that the caller knows that the file
         * descriptor is freed up, as per Austin Group Defect #529.  In fact,
         * EINPROGRESS is to be returned only on signal interruption (i.e.,
         * cancel).  For that reason, this function only ever returns OK.
         */
        force = ((sock->sock_opt & SO_LINGER) && sock->sock_linger == 0);

        if (sock->sock_ops->sop_close != NULL)
                r = sock->sock_ops->sop_close(sock, force);
        else
                r = OK;

        assert(r == OK || r == SUSPEND);

        if (r == SUSPEND) {
                sock->sock_flags |= SFL_CLOSING;

                /*
                 * If we were requested to force-close the socket immediately,
                 * but the socket driver needs more time anyway, then tell the
                 * caller that the socket was closed right away.
                 */
                if (force)
                        return OK;

                /*
                 * If we are to force-close the socket only after a specific
                 * linger timeout, set the timer for that now, even if the call
                 * is non-blocking.  This also means that we cannot associate
                 * the linger timeout with the close call.  Instead, we convert
                 * the sock_linger value from a (relative) duration to an
                 * (absolute) timeout time, and use the SFL_CLOSING flag (along
                 * with SFL_TIMER) to tell the difference.  Since the socket is
                 * otherwise unreachable from userland at this point, the
                 * conversion is never visible in any way.
                 *
                 * The socket may already be in the timers list, so we must
                 * always check the SO_LINGER flag before checking sock_linger.
                 *
                 * If SO_LINGER is not set, we must never suspend the call.
                 */
                if (sock->sock_opt & SO_LINGER) {
                        sock->sock_linger =
                            socktimer_add(sock, sock->sock_linger);
                } else
                        call = NULL;

                /*
                 * A non-blocking close is completed asynchronously.  The
                 * caller is not told about this with EWOULDBLOCK as usual, for
                 * the reasons mentioned above.
                 */
                if (call != NULL)
                        sockevent_suspend(sock, SEV_CLOSE, call, NONE);
                else
                        r = OK;
        } else if (r == OK)
                sockevent_free(sock);

        return r;
}

/*
 * Cancel a suspended send request.
 */
static void
sockevent_cancel_send(struct sock * sock, struct sockevent_proc * spr, int err)
{
        int r;

        /*
         * If any regular or control data were sent, return the number of data
         * bytes sent--possibly zero.  Otherwise return the given error code.
         */
        if (spr->spr_dataoff > 0 || spr->spr_ctloff > 0)
                r = (int)spr->spr_dataoff;
        else
                r = err;

        sockdriver_reply_generic(&spr->spr_call, r);

        /*
         * In extremely rare circumstances, one send may be queued behind
         * another send even though the former can actually be sent on the
         * socket right away.  For this reason, we retry sending when canceling
         * a send.  We need to do this only when the first send in the queue
         * was canceled, but multiple blocked sends on a single socket should
         * be rare anyway.
         */
        sockevent_raise(sock, SEV_SEND);
}

/*
 * Cancel a suspended receive request.
 */
static void
sockevent_cancel_recv(struct sock * sock, struct sockevent_proc * spr, int err)
{
        int r;

        /*
         * If any regular or control data were received, return the number of
         * data bytes received--possibly zero.  Otherwise return the given
         * error code.
         */
        if (spr->spr_dataoff > 0 || spr->spr_ctloff > 0)
                r = (int)spr->spr_dataoff;
        else
                r = err;

        /*
         * Also return any flags set for the data received so far, e.g.
         * MSG_CTRUNC.  Do not return an address: receive calls on unconnected
         * sockets must never block after receiving some data--instead, they
         * are supposed to return MSG_TRUNC if not all data were copied out.
         */
        sockdriver_reply_recv(&spr->spr_call, r, spr->spr_ctloff, NULL, 0,
            spr->spr_rflags);

        /*
         * The same story as for sends (see above) applies to receives,
         * although this case should be even more rare in practice.
         */
        sockevent_raise(sock, SEV_RECV);
}

/*
 * Cancel a previous request that may currently be suspended.  The cancel
 * operation itself does not have a reply.  Instead, if the given request was
 * found to be suspended, that request must be aborted and an appropriate reply
 * must be sent for the request.  If no matching request was found, no reply
 * must be sent at all.
 */
static void
sockevent_cancel(sockid_t id, const struct sockdriver_call * call)
{
        struct sockevent_proc *spr;
        struct sock *sock;

        /*
         * Due to asynchronous close(2) operations, not even the sock object
         * may be found.  If this (entirely legitimate) case, do not send any
         * reply.
         */
        if ((sock = sockhash_get(id)) == NULL)
                return;

        /*
         * The request may already have completed by the time we receive the
         * cancel request, in which case we can not find it.  In this (entirely
         * legitimate) case, do not send any reply.
         */
        if ((spr = sockevent_unsuspend(sock, call)) == NULL)
                return;

        /*
         * We found the operation.  Cancel it according to its call type.
         * Then, once fully done with it, free the suspension data structure.
         *
         * Note that we have to use the call structure from the suspension data
         * structure rather than the given 'call' pointer: only the former
         * includes all the information necessary to resume the request!
         */
        switch (spr->spr_event) {
        case SEV_BIND:
        case SEV_CONNECT:
                assert(spr->spr_call.sc_endpt != NONE);

                sockdriver_reply_generic(&spr->spr_call, EINTR);

                break;

        case SEV_ACCEPT:
                sockdriver_reply_accept(&spr->spr_call, EINTR, NULL, 0);

                break;

        case SEV_SEND:
                sockevent_cancel_send(sock, spr, EINTR);

                break;

        case SEV_RECV:
                sockevent_cancel_recv(sock, spr, EINTR);

                break;

        case SEV_CLOSE:
                /*
                 * Return EINPROGRESS rather than EINTR, so that the user
                 * process can tell from the close(2) result that the file
                 * descriptor has in fact been closed.
                 */
                sockdriver_reply_generic(&spr->spr_call, EINPROGRESS);

                /*
                 * Do not free the sock object here: the socket driver will
                 * complete the close in the background, and fire SEV_CLOSE
                 * once it is done.  Only then is the sock object freed.
                 */
                break;

        default:
                panic("libsockevent: process suspended on unknown event 0x%x",
                    spr->spr_event);
        }

        sockevent_proc_free(spr);
}

/*
 * Process a select request.
 */
static int
sockevent_select(sockid_t id, unsigned int ops,
        const struct sockdriver_select * sel)
{
        struct sock *sock;
        unsigned int r, notify;

        if ((sock = sockhash_get(id)) == NULL)
                return EINVAL;

        notify = (ops & SDEV_NOTIFY);
        ops &= (SDEV_OP_RD | SDEV_OP_WR | SDEV_OP_ERR);

        /*
         * See if any of the requested select operations can be satisfied
         * immediately.
         */
        r = sockevent_test_select(sock, ops);

        /*
         * If select operations were pending, the new results must not indicate
         * that any of those were satisfied, as that would indicate an internal
         * logic error: the socket driver is supposed to update its state
         * proactively, and thus, discovering that things have changed here is
         * not something that should ever happen.
         */
        assert(!(sock->sock_selops & r));

        /*
         * If any select operations are not satisfied immediately, and we are
         * asked to notify the caller when they are satisfied later, save them
         * for later retesting.
         */
        ops &= ~r;

        if (notify && ops != 0) {
                /*
                 * For now, we support only one caller when it comes to select
                 * queries: VFS.  If we want to support a networked file system
                 * (or so) directly calling select as well, this library will
                 * have to be extended accordingly (should not be too hard).
                 */
                if (sock->sock_select.ss_endpt != NONE) {
                        if (sock->sock_select.ss_endpt != sel->ss_endpt) {
                                printf("libsockevent: no support for multiple "
                                    "select callers yet\n");

                                return EIO;
                        }

                        /*
                         * If a select query was already pending for this
                         * caller, we must simply merge in the new operations.
                         */
                        sock->sock_selops |= ops;
                } else {
                        assert(sel->ss_endpt != NONE);

                        sock->sock_select = *sel;
                        sock->sock_selops = ops;
                }
        }

        return r;
}

/*
 * An alarm has triggered.  Expire any timers.  Socket drivers that do not pass
 * clock notification messages to libsockevent must call expire_timers(3)
 * themselves instead.
 */
static void
sockevent_alarm(clock_t now)
{

        expire_timers(now);
}

static const struct sockdriver sockevent_tab = {
        .sdr_socket             = sockevent_socket,
        .sdr_socketpair         = sockevent_socketpair,
        .sdr_bind               = sockevent_bind,
        .sdr_connect            = sockevent_connect,
        .sdr_listen             = sockevent_listen,
        .sdr_accept             = sockevent_accept,
        .sdr_send               = sockevent_send,
        .sdr_recv               = sockevent_recv,
        .sdr_ioctl              = sockevent_ioctl,
        .sdr_setsockopt         = sockevent_setsockopt,
        .sdr_getsockopt         = sockevent_getsockopt,
        .sdr_getsockname        = sockevent_getsockname,
        .sdr_getpeername        = sockevent_getpeername,
        .sdr_shutdown           = sockevent_shutdown,
        .sdr_close              = sockevent_close,
        .sdr_cancel             = sockevent_cancel,
        .sdr_select             = sockevent_select,
        .sdr_alarm              = sockevent_alarm
};

/*
 * Initialize the socket event library.
 */
void
sockevent_init(sockevent_socket_cb_t socket_cb)
{

        sockhash_init();

        socktimer_init();

        sockevent_proc_init();

        SIMPLEQ_INIT(&sockevent_pending);

        assert(socket_cb != NULL);
        sockevent_socket_cb = socket_cb;

        /* Announce we are up. */
        sockdriver_announce();

        sockevent_working = FALSE;
}

/*
 * Process a socket driver request message.
 */
void
sockevent_process(const message * m_ptr, int ipc_status)
{

        /* Block events until after we have processed the request. */
        assert(!sockevent_working);
        sockevent_working = TRUE;

        /* Actually process the request. */
        sockdriver_process(&sockevent_tab, m_ptr, ipc_status);

        /*
         * If any events were fired while processing the request, they will
         * have been queued for later.  Go through them now.
         */
        if (sockevent_has_events())
                sockevent_pump();

        sockevent_working = FALSE;
}