Remove building with NOCRYPTO option

[minix.git] / minix / net / lwip / rtsock.c

/* LWIP service - rtsock.c - routing sockets and route sysctl support */
/*
 * In a nutshell, the intended abstraction is that only this module deals with
 * route messages, message headers, and RTA arrays, whereas other modules
 * (ifaddr, route) are responsible for parsing and providing sockaddr_* type
 * addresses, with the exception of compression and expansion which is
 * particular to routing sockets.  Concretely, there should be no reference to
 * (e.g.) rt_msghdr outside this module, and no mention of ip_addr_t inside it.
 */

#include "lwip.h"
#include "ifaddr.h"
#include "rtsock.h"
#include "route.h"
#include "lldata.h"

/* The number of routing sockets. */
#define NR_RTSOCK               8

/*
 * The send buffer maximum determines the maximum size of requests.  The
 * maximum possible request size is the size of the routing message header plus
 * RTAX_MAX times the maximum socket address size, including alignment.  That
 * currently works out to a number in the low 400s, so 512 should be fine for
 * now.  At this time we do not support changing the send buffer size, because
 * there really is no point in doing so.  Hence also no RT_SNDBUF_{MIN,DEF}.
 */
#define RT_SNDBUF_MAX           512     /* maximum RT send buffer size */

#define RT_RCVBUF_MIN           0       /* minimum RT receive buffer size */
#define RT_RCVBUF_DEF           16384   /* default RT receive buffer size */
#define RT_RCVBUF_MAX           65536   /* maximum RT receive buffer size */

/* Address length of routing socket address structures; two bytes only. */
#define RTSOCK_ADDR_LEN         offsetof(struct sockaddr, sa_data)

struct rtsock_rta {
        const void *rta_ptr[RTAX_MAX];
        socklen_t rta_len[RTAX_MAX];
};

static const char rtsock_padbuf[RT_ROUNDUP(0)];

static struct rtsock {
        struct sock rt_sock;            /* socket object, MUST be first */
        int rt_family;                  /* address family filter if not zero */
        unsigned int rt_flags;          /* routing socket flags (RTF_) */
        struct pbuf *rt_rcvhead;        /* receive buffer, first packet */
        struct pbuf **rt_rcvtailp;      /* receive buffer, last ptr-ptr */
        size_t rt_rcvlen;               /* receive buffer, length in bytes */
        size_t rt_rcvbuf;               /* receive buffer, maximum size */
        TAILQ_ENTRY(rtsock) rt_next;    /* next in active or free list */
} rt_array[NR_RTSOCK];

#define RTF_NOLOOPBACK          0x1     /* suppress reply messages */

static TAILQ_HEAD(, rtsock) rt_freelist;        /* free routing sockets */
static TAILQ_HEAD(, rtsock) rt_activelist;      /* active routing sockets */

struct rtsock_request {
        struct rtsock *rtr_src;         /* source socket of the request */
        pid_t rtr_pid;                  /* process ID of requesting process */
        int rtr_seq;                    /* sequence number from the request */
        int rtr_getif;                  /* RTM_GET only: get interface info */
};

static const struct sockevent_ops rtsock_ops;

static ssize_t rtsock_info(struct rmib_call *, struct rmib_node *,
        struct rmib_oldp *, struct rmib_newp *);

/* The CTL_NET PF_ROUTE subtree. */
static struct rmib_node net_route_table[] = {
        [0]     = RMIB_FUNC(RMIB_RO | CTLTYPE_NODE, 0, rtsock_info,
                    "rtable", "Routing table information"),
};

/* The CTL_NET PF_ROUTE node. */
static struct rmib_node net_route_node =
    RMIB_NODE(RMIB_RO, net_route_table, "route", "PF_ROUTE information");

/*
 * Initialize the routing sockets module.
 */
void
rtsock_init(void)
{
        const int mib[] = { CTL_NET, PF_ROUTE };
        unsigned int slot;
        int r;

        /* Initialize the list of free routing sockets. */
        TAILQ_INIT(&rt_freelist);

        for (slot = 0; slot < __arraycount(rt_array); slot++)
                TAILQ_INSERT_TAIL(&rt_freelist, &rt_array[slot], rt_next);

        /* Initialize the list of acive routing sockets. */
        TAILQ_INIT(&rt_activelist);

        /* Register the "net.route" subtree with the MIB service. */
        if ((r = rmib_register(mib, __arraycount(mib), &net_route_node)) != OK)
                panic("unable to register net.route RMIB tree: %d", r);
}

/*
 * Allocate a pbuf suitable for storing a routing message of 'size' bytes.
 * Return the allocated pbuf on success, or NULL on memory allocation failure.
 */
static struct pbuf *
rtsock_alloc(size_t size)
{
        struct pbuf *pbuf;

        /*
         * The data will currently always fit in a single pool buffer.  Just in
         * case this changes in the future, warn and fail cleanly.  The rest of
         * the code is not able to deal with buffer chains as it is, although
         * that can be changed if necessary.
         */
        if (size > MEMPOOL_BUFSIZE) {
                printf("LWIP: routing socket packet too large (%zu)\n", size);

                return NULL;
        }

        pbuf = pbuf_alloc(PBUF_RAW, size, PBUF_RAM);

        assert(pbuf == NULL || pbuf->tot_len == pbuf->len);

        return pbuf;
}

/*
 * Initialize a routing addresses map.
 */
static void
rtsock_rta_init(struct rtsock_rta * rta)
{

        memset(rta, 0, sizeof(*rta));
}

/*
 * Set an entry in a routing addresses map.  When computing sizes, 'ptr' may be
 * NULL.
 */
static void
rtsock_rta_set(struct rtsock_rta * rta, unsigned int rtax, const void * ptr,
        socklen_t len)
{

        assert(rtax < RTAX_MAX);

        rta->rta_ptr[rtax] = ptr;
        rta->rta_len[rtax] = len;
}

/*
 * Copy out a message with a header and any entries in a routing addresses map,
 * either into a pbuf allocated for this purpose, or to a RMIB (sysctl) caller,
 * at the given offset.  If no destination is given ('pbuf ' and 'oldp' are
 * both NULL), compute just the size of the resulting data.  Otherwise, set the
 * length and address mask fields in the header as a side effect.  Return the
 * number of bytes copied on success, and if 'pbuf' is not NULL, it is filled
 * with a pointer to the newly allocated pbuf.  Return a negative error code on
 * failure.  Note that when computing the size only, any actual data pointers
 * ('hdr', 'msglen', 'addrs', and the pointers in 'rta') may be NULL or even
 * invalid, even though the corresponding sizes should still be supplied.
 */
static ssize_t
rtsock_rta_finalize(void * hdr, size_t hdrlen, u_short * msglen, int * addrs,
        const struct rtsock_rta * rta, struct pbuf ** pbuf,
        struct rmib_oldp * oldp, ssize_t off)
{
        iovec_t iov[1 + RTAX_MAX * 2];
        size_t len, padlen, totallen;
        unsigned int i, iovcnt;
        int mask;

        assert(pbuf == NULL || oldp == NULL);
        assert(pbuf == NULL || off == 0);
        assert(RT_ROUNDUP(hdrlen) == hdrlen);

        iov[0].iov_addr = (vir_bytes)hdr;
        iov[0].iov_size = hdrlen;
        iovcnt = 1;

        totallen = hdrlen;
        mask = 0;

        /*
         * The addresses in the given RTA map, as present, should be stored in
         * the numbering order of the map.
         */
        for (i = 0; i < RTAX_MAX; i++) {
                if (rta->rta_ptr[i] == NULL)
                        continue;

                if ((len = rta->rta_len[i]) > 0) {
                        assert(iovcnt < __arraycount(iov));
                        iov[iovcnt].iov_addr = (vir_bytes)rta->rta_ptr[i];
                        iov[iovcnt++].iov_size = len;
                }

                /* Note that RT_ROUNDUP(0) is not 0.. */
                if ((padlen = RT_ROUNDUP(len) - len) > 0) {
                        assert(iovcnt < __arraycount(iov));
                        iov[iovcnt].iov_addr = (vir_bytes)rtsock_padbuf;
                        iov[iovcnt++].iov_size = padlen;
                }

                totallen += len + padlen;
                mask |= (1 << i);       /* convert RTAX_ to RTA_ */
        }

        /* If only the length was requested, return it now. */
        if (pbuf == NULL && oldp == NULL)
                return totallen;

        /*
         * Casting 'hdr' would violate C99 strict aliasing rules, but the
         * address mask is not always at the same location anyway.
         */
        *msglen = totallen;
        *addrs = mask;

        if (pbuf != NULL) {
                if ((*pbuf = rtsock_alloc(totallen)) == NULL)
                        return ENOMEM;

                return util_coalesce((char *)(*pbuf)->payload, totallen, iov,
                    iovcnt);
        } else
                return rmib_vcopyout(oldp, off, iov, iovcnt);
}

/*
 * Reduce the size of a network mask to the bytes actually used.  It is highly
 * doubtful that this extra complexity pays off in any form, but it is what the
 * BSDs historically do.  We currently implement compression for IPv4 only.
 */
static void
rtsock_compress_netmask(struct sockaddr * sa)
{
        struct sockaddr_in sin;
        uint32_t addr;

        if (sa->sa_family != AF_INET)
                return; /* nothing to do */

        memcpy(&sin, sa, sizeof(sin));  /* no type punning.. (sigh) */

        addr = htonl(sin.sin_addr.s_addr);

        if (addr & 0x000000ff)
                sa->sa_len = 8;
        else if (addr & 0x0000ffff)
                sa->sa_len = 7;
        else if (addr & 0x00ffffff)
                sa->sa_len = 6;
        else if (addr != 0)
                sa->sa_len = 5;
        else
                sa->sa_len = 0;
}

/*
 * Expand a possibly compressed IPv4 or IPv6 network mask, given as 'sa', into
 * 'mask'.  Return TRUE if expansion succeeded.  In that case, the resulting
 * mask must have sa.sa_len and sa.sa_family filled in correctly, and have the
 * appropriate size for its address family.  Return FALSE if expansion failed
 * and an error should be returned to the caller.
 */
static int
rtsock_expand_netmask(union sockaddr_any * mask, const struct sockaddr * sa)
{

        if (sa->sa_len > sizeof(*mask))
                return FALSE;

        memset(mask, 0, sizeof(*mask));
        memcpy(mask, sa, sa->sa_len);

        /*
         * Amazingly, even the address family may be chopped off, in which case
         * an IPv4 address is implied.
         */
        if (sa->sa_len >= offsetof(struct sockaddr, sa_data) &&
            sa->sa_family == AF_INET6) {
                if (sa->sa_len > sizeof(struct sockaddr_in6))
                        return FALSE;

                mask->sa.sa_len = sizeof(struct sockaddr_in6);
                mask->sa.sa_family = AF_INET6;
        } else {
                if (sa->sa_len > sizeof(struct sockaddr_in))
                        return FALSE;

                mask->sa.sa_len = sizeof(struct sockaddr_in);
                mask->sa.sa_family = AF_INET;
        }

        return TRUE;
}

/*
 * Create a routing socket.
 */
sockid_t
rtsock_socket(int type, int protocol, struct sock ** sockp,
        const struct sockevent_ops ** ops)
{
        struct rtsock *rt;

        /*
         * There is no superuser check here: regular users are allowed to issue
         * (only) RTM_GET requests on routing sockets.
         */
        if (type != SOCK_RAW)
                return EPROTOTYPE;

        /* We could accept only the protocols we know, but this is fine too. */
        if (protocol < 0 || protocol >= AF_MAX)
                return EPROTONOSUPPORT;

        if (TAILQ_EMPTY(&rt_freelist))
                return ENOBUFS;

        rt = TAILQ_FIRST(&rt_freelist);
        TAILQ_REMOVE(&rt_freelist, rt, rt_next);

        rt->rt_flags = 0;
        rt->rt_family = protocol;
        rt->rt_rcvhead = NULL;
        rt->rt_rcvtailp = &rt->rt_rcvhead;
        rt->rt_rcvlen = 0;
        rt->rt_rcvbuf = RT_RCVBUF_DEF;

        TAILQ_INSERT_HEAD(&rt_activelist, rt, rt_next);

        *sockp = &rt->rt_sock;
        *ops = &rtsock_ops;
        return SOCKID_RT | (sockid_t)(rt - rt_array);
}

/*
 * Enqueue data on the receive queue of a routing socket.  The caller must have
 * checked whether the receive buffer size allows for the receipt of the data.
 */
static void
rtsock_enqueue(struct rtsock * rt, struct pbuf * pbuf)
{

        *rt->rt_rcvtailp = pbuf;
        rt->rt_rcvtailp = pchain_end(pbuf);
        rt->rt_rcvlen += pchain_size(pbuf);

        sockevent_raise(&rt->rt_sock, SEV_RECV);
}

/*
 * Determine whether a routing message for address family 'family', originated
 * from routing socket 'rtsrc' if not NULL, should be sent to routing socket
 * 'rt'.  Return TRUE if the message should be sent to this socket, or FALSE
 * if it should not.
 */
static int
rtsock_can_send(struct rtsock *rt, struct rtsock *rtsrc, int family)
{

        /* Do not send anything on sockets shut down for reading. */
        if (sockevent_is_shutdown(&rt->rt_sock, SFL_SHUT_RD))
                return FALSE;

        /*
         * Do not send a reply message to the source of the request if the
         * source is not interested in replies to its own requests.
         */
        if (rt == rtsrc && (rt->rt_flags & RTF_NOLOOPBACK))
                return FALSE;

        /*
         * For address family specific messages, make sure the routing socket
         * is interested in that family.  Make an exception if the socket was
         * the source of the request, though: we currently do not prevent user
         * processes from issuing commands for the "wrong" family.
         */
        if (rt->rt_family != AF_UNSPEC && family != AF_UNSPEC &&
            rt->rt_family != family && rt != rtsrc)
                return FALSE;

        /*
         * See whether the receive queue of the socket is already full.  We do
         * not consider the size of the current request, in order to not drop
         * larger messages and then enqueue smaller ones.
         */
        if (rt->rt_rcvlen >= rt->rt_rcvbuf)
                return FALSE;

        /* All is well: go on and deliver the message. */
        return TRUE;
}

/*
 * Send the routing message in 'pbuf' to the given routing socket if possible,
 * or check whether such a message could be sent to that socket if 'pbuf' is
 * NULL.  In the former case, the function takes ownership of 'pbuf'.  The
 * given routing socket is assumed to be the source of the routing request that
 * generated this message.  In the latter case, the function returns TRUE if
 * the socket would take the message or FALSE if not.  If 'family' is not
 * AF_UNSPEC, it is to be the address family of the message.
 */
static int
rtsock_msg_one(struct rtsock * rt, int family, struct pbuf * pbuf)
{

        if (rtsock_can_send(rt, rt, family)) {
                if (pbuf != NULL)
                        rtsock_enqueue(rt, pbuf);

                return TRUE;
        } else {
                if (pbuf != NULL)
                        pbuf_free(pbuf);

                return FALSE;
        }
}

/*
 * Send the routing message in 'pbuf' to all matching routing sockets, or check
 * whether there are any such matching routing sockets if 'pbuf' is NULL.  In
 * the former case, the function takes ownership of 'pbuf'.  In the latter
 * case, the function returns TRUE if there are any matching sockets or FALSE
 * if there are none.  If 'rtsrc' is not NULL, it is to be the routing socket
 * that is the source of the message.  If 'family' is not AF_UNSPEC, it is to
 * be the address family of the message.
 */
static int
rtsock_msg_match(struct rtsock * rtsrc, int family, struct pbuf * pbuf)
{
        struct rtsock *rt, *rtprev;
        struct pbuf *pcopy;

        rtprev = NULL;

        TAILQ_FOREACH(rt, &rt_activelist, rt_next) {
                if (!rtsock_can_send(rt, rtsrc, family))
                        continue;

                /*
                 * There is at least one routing socket that is interested in
                 * receiving this message, and able to receive it.
                 */
                if (pbuf == NULL)
                        return TRUE;

                /*
                 * We need to make copies of the generated message for all but
                 * the last matching socket, which gets the original.  If we're
                 * out of memory, free the original and stop: there are more
                 * important things to spend memory on than routing sockets.
                 */
                if (rtprev != NULL) {
                        if ((pcopy = rtsock_alloc(pbuf->tot_len)) == NULL) {
                                pbuf_free(pbuf);

                                return TRUE;
                        }

                        if (pbuf_copy(pcopy, pbuf) != ERR_OK)
                                panic("unexpected pbuf copy failure");

                        rtsock_enqueue(rtprev, pcopy);
                }

                rtprev = rt;
        }

        if (rtprev != NULL)
                rtsock_enqueue(rtprev, pbuf);
        else if (pbuf != NULL)
                pbuf_free(pbuf);

        return (rtprev != NULL);
}

/*
 * Dequeue and free the head of the receive queue of a routing socket.
 */
static void
rtsock_dequeue(struct rtsock * rt)
{
        struct pbuf *pbuf, **pnext;
        size_t size;

        pbuf = rt->rt_rcvhead;
        assert(pbuf != NULL);

        pnext = pchain_end(pbuf);
        size = pchain_size(pbuf);

        if ((rt->rt_rcvhead = *pnext) == NULL)
                rt->rt_rcvtailp = &rt->rt_rcvhead;

        assert(rt->rt_rcvlen >= size);
        rt->rt_rcvlen -= size;

        *pnext = NULL;
        pbuf_free(pbuf);
}

/*
 * Process a routing message sent on a socket.  Return OK on success, in which
 * case the caller assumes that the processing routine has sent a reply to the
 * user and possibly other routing sockets.  Return a negative error code on
 * failure, in which case the caller will send the reply to the user instead.
 */
static int
rtsock_process(struct rtsock *rt, struct rt_msghdr * rtm, char * buf,
        size_t len, int is_root)
{
        struct rtsock_request rtr;
        struct rtsock_rta rta;
        const struct sockaddr *netmask;
        struct sockaddr sa;
        union sockaddr_any mask;
        size_t off;
        int i;

        if (rtm->rtm_msglen != len)
                return EINVAL;

        if (rtm->rtm_version != RTM_VERSION) {
                printf("LWIP: PID %d uses routing sockets version %u\n",
                        rtm->rtm_pid, rtm->rtm_version);

                return EPROTONOSUPPORT;
        }

        /*
         * Make sure that we won't misinterpret the rest of the message.  While
         * looking at the message type, also make sure non-root users can only
         * ever issue RTM_GET requests.
         */
        switch (rtm->rtm_type) {
        case RTM_ADD:
        case RTM_DELETE:
        case RTM_CHANGE:
        case RTM_LOCK:
                if (!is_root)
                        return EPERM;

                /* FALLTHROUGH */
        case RTM_GET:
                break;

        default:
                return EOPNOTSUPP;
        }

        /*
         * Extract all given addresses.  We do not actually support all types
         * of entries, but we cannot skip the ones we do not need either.
         */
        rtsock_rta_init(&rta);

        off = sizeof(*rtm);
        assert(off == RT_ROUNDUP(off));

        for (i = 0; i < RTAX_MAX; i++) {
                if (!(rtm->rtm_addrs & (1 << i)))
                        continue;

                if (off + offsetof(struct sockaddr, sa_data) > len)
                        return EINVAL;

                /*
                 * It is safe to access sa_len and even sa_family in all cases,
                 * in particular even when the structure is of size zero.
                 */
                assert(offsetof(struct sockaddr, sa_data) <= RT_ROUNDUP(0));

                memcpy(&sa, &buf[off], offsetof(struct sockaddr, sa_data));

                if (off + sa.sa_len > len)
                        return EINVAL;

                rtsock_rta_set(&rta, i, &buf[off], sa.sa_len);

                off += RT_ROUNDUP((size_t)sa.sa_len);
        }

        /*
         * Expand the given netmask if it is in compressed IPv4 form.  We do
         * this here because it is particular to routing sockets; we also do
         * the compression in this module.  Note how the compression may even
         * strip off the address family; really, who came up with this ****?
         */
        netmask = (const struct sockaddr *)rta.rta_ptr[RTAX_NETMASK];

        if (netmask != NULL) {
                if (!rtsock_expand_netmask(&mask, netmask))
                        return EINVAL;

                rtsock_rta_set(&rta, RTAX_NETMASK, &mask, mask.sa.sa_len);
        }

        /*
         * Actually process the command.  Pass on enough information so that a
         * reply can be generated on success.  The abstraction as sketched at
         * the top of the file imposes that we pass quite a few parameters.
         */
        rtr.rtr_src = rt;
        rtr.rtr_pid = rtm->rtm_pid;
        rtr.rtr_seq = rtm->rtm_seq;
        rtr.rtr_getif = (rtm->rtm_type == RTM_GET &&
            (rta.rta_ptr[RTAX_IFP] != NULL || rta.rta_ptr[RTAX_IFA] != NULL));

        return route_process(rtm->rtm_type,
            (const struct sockaddr *)rta.rta_ptr[RTAX_DST],
            (const struct sockaddr *)rta.rta_ptr[RTAX_NETMASK],
            (const struct sockaddr *)rta.rta_ptr[RTAX_GATEWAY],
            (const struct sockaddr *)rta.rta_ptr[RTAX_IFP],
            (const struct sockaddr *)rta.rta_ptr[RTAX_IFA],
            rtm->rtm_flags, rtm->rtm_inits, &rtm->rtm_rmx, &rtr);
}

/*
 * Perform preliminary checks on a send request.
 */
static int
rtsock_pre_send(struct sock * sock __unused, size_t len,
        socklen_t ctl_len __unused, const struct sockaddr * addr,
        socklen_t addr_len __unused, endpoint_t user_endpt __unused, int flags)
{

        if (flags != 0)
                return EOPNOTSUPP;

        if (addr != NULL)
                return EISCONN;

        /*
         * For the most basic failures - that is, we cannot even manage to
         * receive the request - we do not generate a reply message.
         */
        if (len < sizeof(struct rt_msghdr))
                return ENOBUFS;
        if (len > RT_SNDBUF_MAX)
                return EMSGSIZE;

        return OK;
}

/*
 * Send data on a routing socket.
 */
static int
rtsock_send(struct sock * sock, const struct sockdriver_data * data,
        size_t len, size_t * offp, const struct sockdriver_data * ctl __unused,
        socklen_t ctl_len __unused, socklen_t * ctl_off __unused,
        const struct sockaddr * addr __unused, socklen_t addr_len __unused,
        endpoint_t user_endpt, int flags __unused, size_t min __unused)
{
        struct rtsock *rt = (struct rtsock *)sock;
        char buf[RT_SNDBUF_MAX] __aligned(4);
        struct rt_msghdr rtm;
        struct pbuf *pbuf;
        uid_t euid;
        int r, is_root;

        /* Copy in the request, and adjust some fields right away. */
        assert(len >= sizeof(rtm));
        assert(len <= sizeof(buf));

        if ((r = sockdriver_copyin(data, 0, buf, len)) != OK)
                return r;

        memcpy(&rtm, buf, sizeof(rtm));
        rtm.rtm_errno = 0;
        rtm.rtm_flags &= ~RTF_DONE;
        rtm.rtm_pid = getepinfo(user_endpt, &euid, NULL /*gid*/);

        is_root = (euid == ROOT_EUID);

        /* Process the request. */
        r = rtsock_process(rt, &rtm, buf, len, is_root);

        /*
         * If the request has been processed successfully, a reply has been
         * sent already, possibly also to other routing sockets.  Here, we
         * handle the case that the request has resulted in failure, in which
         * case we send a reply to the caller only.  This behavior is different
         * from the traditional BSD behavior, which also sends failure replies
         * to other sockets.  Our motivation is that while other parties are
         * never going to be interested in failures anyway, it is in fact easy
         * for an unprivileged user process to abuse the failure-reply system
         * in order to fake other types of routing messages (e.g., RTM_IFINFO)
         * to other parties.  By sending failure replies only to the requestor,
         * we eliminate the need for security-sensitive request validation.
         */
        if (r != OK && rtsock_can_send(rt, rt, AF_UNSPEC)) {
                rtm.rtm_errno = -r;

                if ((pbuf = rtsock_alloc(len)) == NULL)
                        return ENOMEM;

                /* For the reply, reuse the request message largely as is. */
                memcpy(pbuf->payload, &rtm, sizeof(rtm));
                if (len > sizeof(rtm))
                        memcpy((uint8_t *)pbuf->payload + sizeof(rtm),
                            buf + sizeof(rtm), len - sizeof(rtm));

                rtsock_enqueue(rt, pbuf);
        } else if (r == OK)
                *offp = len;

        return r;
}

/*
 * Perform preliminary checks on a receive request.
 */
static int
rtsock_pre_recv(struct sock * sock __unused, endpoint_t user_endpt __unused,
        int flags)
{

        /*
         * We accept the same flags across all socket types in LWIP, and then
         * simply ignore the ones we do not support for routing sockets.
         */
        if ((flags & ~(MSG_PEEK | MSG_WAITALL)) != 0)
                return EOPNOTSUPP;

        return OK;
}

/*
 * Receive data on a routing socket.
 */
static int
rtsock_recv(struct sock * sock, const struct sockdriver_data * data,
        size_t len, size_t * off, const struct sockdriver_data * ctl __unused,
        socklen_t ctl_len __unused, socklen_t * ctl_off __unused,
        struct sockaddr * addr, socklen_t * addr_len,
        endpoint_t user_endpt __unused, int flags, size_t min __unused,
        int * rflags)
{
        struct rtsock *rt = (struct rtsock *)sock;
        struct pbuf *pbuf;
        int r;

        if ((pbuf = rt->rt_rcvhead) == NULL)
                return SUSPEND;

        /* Copy out the data to the calling user process. */
        if (len >= pbuf->tot_len)
                len = pbuf->tot_len;
        else
                *rflags |= MSG_TRUNC;

        r = util_copy_data(data, len, 0, pbuf, 0, FALSE /*copy_in*/);

        if (r != OK)
                return r;

        /* Generate a dummy source address. */
        addr->sa_len = RTSOCK_ADDR_LEN;
        addr->sa_family = AF_ROUTE;
        *addr_len = RTSOCK_ADDR_LEN;

        /* Discard the data now, unless we were instructed to peek only. */
        if (!(flags & MSG_PEEK))
                rtsock_dequeue(rt);

        /* Return the received part of the data length. */
        *off = len;
        return OK;
}

/*
 * Test whether data can be received on a routing socket, and if so, how many
 * bytes of data.
 */
static int
rtsock_test_recv(struct sock * sock, size_t min __unused, size_t * size)
{
        struct rtsock *rt = (struct rtsock *)sock;

        if (rt->rt_rcvhead == NULL)
                return SUSPEND;

        if (size != NULL)
                *size = rt->rt_rcvhead->tot_len;
        return OK;
}

/*
 * Set socket options on a routing socket.
 */
static int
rtsock_setsockopt(struct sock * sock, int level, int name,
        const struct sockdriver_data * data, socklen_t len)
{
        struct rtsock *rt = (struct rtsock *)sock;
        int r, val;

        if (level == SOL_SOCKET) {
                switch (name) {
                case SO_USELOOPBACK:
                        if ((r = sockdriver_copyin_opt(data, &val, sizeof(val),
                            len)) != OK)
                                return r;

                        if (!val)
                                rt->rt_flags |= RTF_NOLOOPBACK;
                        else
                                rt->rt_flags &= ~RTF_NOLOOPBACK;

                        return OK;

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

                        if (val < RT_RCVBUF_MIN || val > RT_RCVBUF_MAX)
                                return EINVAL;

                        rt->rt_rcvbuf = (size_t)val;

                        return OK;
                }
        }

        return ENOPROTOOPT;
}

/*
 * Retrieve socket options on a routing socket.
 */
static int
rtsock_getsockopt(struct sock * sock, int level, int name,
        const struct sockdriver_data * data, socklen_t * len)
{
        struct rtsock *rt = (struct rtsock *)sock;
        int val;

        if (level == SOL_SOCKET) {
                switch (name) {
                case SO_USELOOPBACK:
                        val = !(rt->rt_flags & RTF_NOLOOPBACK);

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

                case SO_RCVBUF:
                        val = rt->rt_rcvbuf;

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

        return ENOPROTOOPT;
}

/*
 * Retrieve the local or remote socket address of a routing socket.
 */
static int
rtsock_getname(struct sock * sock __unused, struct sockaddr * addr,
        socklen_t * addr_len)
{

        /* This is entirely useless but apparently common between OSes. */
        addr->sa_len = RTSOCK_ADDR_LEN;
        addr->sa_family = AF_ROUTE;
        *addr_len = RTSOCK_ADDR_LEN;

        return OK;
}

/*
 * Drain the receive queue of a routing socket.
 */
static void
rtsock_drain(struct rtsock * rt)
{

        while (rt->rt_rcvhead != NULL)
                rtsock_dequeue(rt);
}

/*
 * Shut down a routing socket for reading and/or writing.
 */
static int
rtsock_shutdown(struct sock * sock, unsigned int mask)
{
        struct rtsock *rt = (struct rtsock *)sock;

        if (mask & SFL_SHUT_RD)
                rtsock_drain(rt);

        return OK;
}

/*
 * Close a routing socket.
 */
static int
rtsock_close(struct sock * sock, int force __unused)
{
        struct rtsock *rt = (struct rtsock *)sock;

        rtsock_drain(rt);

        return OK;
}

/*
 * Free up a closed routing socket.
 */
static void
rtsock_free(struct sock * sock)
{
        struct rtsock *rt = (struct rtsock *)sock;

        TAILQ_REMOVE(&rt_activelist, rt, rt_next);

        TAILQ_INSERT_HEAD(&rt_freelist, rt, rt_next);
}

static const struct sockevent_ops rtsock_ops = {
        .sop_pre_send           = rtsock_pre_send,
        .sop_send               = rtsock_send,
        .sop_pre_recv           = rtsock_pre_recv,
        .sop_recv               = rtsock_recv,
        .sop_test_recv          = rtsock_test_recv,
        .sop_setsockopt         = rtsock_setsockopt,
        .sop_getsockopt         = rtsock_getsockopt,
        .sop_getsockname        = rtsock_getname,
        .sop_getpeername        = rtsock_getname,
        .sop_shutdown           = rtsock_shutdown,
        .sop_close              = rtsock_close,
        .sop_free               = rtsock_free
};

/*
 * Send an interface announcement message about the given interface.  If
 * 'arrival' is set, the interface has just been created; otherwise, the
 * interface is about to be destroyed.
 */
void
rtsock_msg_ifannounce(struct ifdev * ifdev, int arrival)
{
        struct if_announcemsghdr ifan;
        struct pbuf *pbuf;

        if (!rtsock_msg_match(NULL /*rtsrc*/, AF_UNSPEC, NULL /*pbuf*/))
                return;

        memset(&ifan, 0, sizeof(ifan));
        ifan.ifan_msglen = sizeof(ifan);
        ifan.ifan_version = RTM_VERSION;
        ifan.ifan_type = RTM_IFANNOUNCE;
        ifan.ifan_index = ifdev_get_index(ifdev);
        strlcpy(ifan.ifan_name, ifdev_get_name(ifdev), sizeof(ifan.ifan_name));
        ifan.ifan_what = (arrival) ? IFAN_ARRIVAL : IFAN_DEPARTURE;

        if ((pbuf = rtsock_alloc(sizeof(ifan))) == NULL)
                return;
        memcpy(pbuf->payload, &ifan, sizeof(ifan));

        rtsock_msg_match(NULL /*rtsrc*/, AF_UNSPEC, pbuf);
}

/*
 * Send an interface information routing message.
 */
void
rtsock_msg_ifinfo(struct ifdev * ifdev)
{
        struct if_msghdr ifm;
        struct pbuf *pbuf;

        if (!rtsock_msg_match(NULL /*rtsrc*/, AF_UNSPEC, NULL /*pbuf*/))
                return;

        memset(&ifm, 0, sizeof(ifm));
        ifm.ifm_msglen = sizeof(ifm);
        ifm.ifm_version = RTM_VERSION;
        ifm.ifm_type = RTM_IFINFO;
        ifm.ifm_addrs = 0;
        ifm.ifm_flags = ifdev_get_ifflags(ifdev);
        ifm.ifm_index = ifdev_get_index(ifdev);
        memcpy(&ifm.ifm_data, ifdev_get_ifdata(ifdev), sizeof(ifm.ifm_data));

        if ((pbuf = rtsock_alloc(sizeof(ifm))) == NULL)
                return;
        memcpy(pbuf->payload, &ifm, sizeof(ifm));

        rtsock_msg_match(NULL /*rtsrc*/, AF_UNSPEC, pbuf);
}

/*
 * Set up a RTA map and an interface address structure for use in a RTM_xxxADDR
 * routing message.
 */
static void
rtsock_rta_init_ifam(struct rtsock_rta * rta, struct ifa_msghdr * ifam,
        struct ifdev * ifdev, unsigned int type, struct sockaddr_dlx * sdlx)
{

        memset(ifam, 0, sizeof(*ifam));
        ifam->ifam_version = RTM_VERSION;
        ifam->ifam_type = type;
        ifam->ifam_flags = 0;
        ifam->ifam_index = ifdev_get_index(ifdev);
        ifam->ifam_metric = ifdev_get_metric(ifdev);

        rtsock_rta_init(rta);

        ifaddr_dl_get(ifdev, (ifaddr_dl_num_t)0, sdlx);

        rtsock_rta_set(rta, RTAX_IFP, sdlx, sdlx->sdlx_len);
}

/*
 * Add a specific link-layer address for an interface to the given RTA map.
 */
static void
rtsock_rta_add_dl(struct rtsock_rta * rta, struct ifdev * ifdev,
        ifaddr_dl_num_t num, struct sockaddr_dlx * sdlx)
{

        /* Obtain the address data. */
        ifaddr_dl_get(ifdev, num, sdlx);

        /* Add the interface address. */
        rtsock_rta_set(rta, RTAX_IFA, sdlx, sdlx->sdlx_len);

        /*
         * NetBSD also adds a RTAX_NETMASK entry here.  At this moment it is
         * not clear to me why, and it is a pain to make, so for now we do not.
         */
}

/*
 * Send a routing message about a new, changed, or deleted datalink address for
 * the given interface.
 */
void
rtsock_msg_addr_dl(struct ifdev * ifdev, unsigned int type,
        ifaddr_dl_num_t num)
{
        struct rtsock_rta rta;
        struct ifa_msghdr ifam;
        struct sockaddr_dlx name, addr;
        struct pbuf *pbuf;

        if (!rtsock_msg_match(NULL /*rtsrc*/, AF_LINK, NULL /*pbuf*/))
                return;

        rtsock_rta_init_ifam(&rta, &ifam, ifdev, type, &name);

        rtsock_rta_add_dl(&rta, ifdev, num, &addr);

        if (rtsock_rta_finalize(&ifam, sizeof(ifam), &ifam.ifam_msglen,
            &ifam.ifam_addrs, &rta, &pbuf, NULL, 0) > 0)
                rtsock_msg_match(NULL /*rtsrc*/, AF_LINK, pbuf);
}

/*
 * Add a specific IPv4 address for an interface to the given RTA map.
 */
static void
rtsock_rta_add_v4(struct rtsock_rta * rta, struct ifdev * ifdev,
        ifaddr_v4_num_t num, struct sockaddr_in sin[4])
{

        /* Obtain the address data. */
        (void)ifaddr_v4_get(ifdev, num, &sin[0], &sin[1], &sin[2], &sin[3]);

        /* Add the interface address. */
        rtsock_rta_set(rta, RTAX_IFA, &sin[0], sin[0].sin_len);

        /* Add the netmask, after compressing it. */
        rtsock_compress_netmask((struct sockaddr *)&sin[1]);

        rtsock_rta_set(rta, RTAX_NETMASK, &sin[1], sin[1].sin_len);

        /* Possibly add a broadcast or destination address. */
        if (sin[2].sin_len != 0)
                rtsock_rta_set(rta, RTAX_BRD, &sin[2], sin[2].sin_len);
        else if (sin[3].sin_len != 0)
                rtsock_rta_set(rta, RTAX_DST, &sin[3], sin[3].sin_len);
}

/*
 * Send a routing message about a new or deleted IPv4 address for the given
 * interface.
 */
void
rtsock_msg_addr_v4(struct ifdev * ifdev, unsigned int type,
        ifaddr_v4_num_t num)
{
        struct rtsock_rta rta;
        struct ifa_msghdr ifam;
        struct sockaddr_dlx name;
        struct sockaddr_in sin[4];
        struct pbuf *pbuf;

        if (!rtsock_msg_match(NULL /*rtsrc*/, AF_INET, NULL /*pbuf*/))
                return;

        rtsock_rta_init_ifam(&rta, &ifam, ifdev, type, &name);

        rtsock_rta_add_v4(&rta, ifdev, num, sin);

        if (rtsock_rta_finalize(&ifam, sizeof(ifam), &ifam.ifam_msglen,
            &ifam.ifam_addrs, &rta, &pbuf, NULL, 0) > 0)
                rtsock_msg_match(NULL /*rtsrc*/, AF_INET, pbuf);
}

/*
 * Add a specific IPv6 address for an interface to the given RTA map.
 */
static void
rtsock_rta_add_v6(struct rtsock_rta * rta, struct ifdev * ifdev,
        ifaddr_v6_num_t num, struct sockaddr_in6 sin6[3])
{

        /* Obtain the address data. */
        ifaddr_v6_get(ifdev, num, &sin6[0], &sin6[1], &sin6[2]);

        /* Add the interface address. */
        rtsock_rta_set(rta, RTAX_IFA, &sin6[0], sin6[0].sin6_len);

        /* Add the netmask, after compressing it (a no-op at the moment). */
        rtsock_compress_netmask((struct sockaddr *)&sin6[1]);

        rtsock_rta_set(rta, RTAX_NETMASK, &sin6[1], sin6[1].sin6_len);

        /* Possibly add a destination address. */
        if (sin6[2].sin6_len != 0)
                rtsock_rta_set(rta, RTAX_DST, &sin6[2], sin6[2].sin6_len);
}

/*
 * Send a routing message about a new or deleted IPv6 address for the given
 * interface.
 */
void
rtsock_msg_addr_v6(struct ifdev * ifdev, unsigned int type,
        ifaddr_v6_num_t num)
{
        struct rtsock_rta rta;
        struct ifa_msghdr ifam;
        struct sockaddr_dlx name;
        struct sockaddr_in6 sin6[3];
        struct pbuf *pbuf;

        if (!rtsock_msg_match(NULL /*rtsrc*/, AF_INET6, NULL /*pbuf*/))
                return;

        rtsock_rta_init_ifam(&rta, &ifam, ifdev, type, &name);

        rtsock_rta_add_v6(&rta, ifdev, num, sin6);

        if (rtsock_rta_finalize(&ifam, sizeof(ifam), &ifam.ifam_msglen,
            &ifam.ifam_addrs, &rta, &pbuf, NULL, 0) > 0)
                rtsock_msg_match(NULL /*rtsrc*/, AF_INET6, pbuf);
}

/*
 * Send an RTM_MISS routing message about an address for which no route was
 * found.  The caller must provide the address in the appropriate form and
 * perform any per-address rate limiting.
 */
void
rtsock_msg_miss(const struct sockaddr * addr)
{
        struct rt_msghdr rtm;
        struct rtsock_rta rta;
        struct pbuf *pbuf;

        /*
         * Unfortunately the destination address has already been generated (as
         * 'addr'), which is a big part of the work.  Still, skip the rest if
         * there is no routing socket to deliver the message to.
         */
        if (!rtsock_msg_match(NULL /*rtsrc*/, addr->sa_family, NULL /*pbuf*/))
                return;

        memset(&rtm, 0, sizeof(rtm));
        rtm.rtm_version = RTM_VERSION;
        rtm.rtm_type = RTM_MISS;

        rtsock_rta_init(&rta);

        rtsock_rta_set(&rta, RTAX_DST, addr, addr->sa_len);

        if (rtsock_rta_finalize(&rtm, sizeof(rtm), &rtm.rtm_msglen,
            &rtm.rtm_addrs, &rta, &pbuf, NULL, 0) > 0)
                rtsock_msg_match(NULL /*rtsrc*/, addr->sa_family, pbuf);
}

/*
 * Generate routing socket data for a route, for either routing socket
 * broadcasting or a sysctl(7) request.  The route is given as 'route'.  The
 * type of the message (RTM_) is given as 'type'.  The resulting routing
 * message header is stored in 'rtm' and an address vector is stored in 'rta'.
 * The latter may point to addresses generated in 'addr', 'mask', 'gateway',
 * and optionally (if not NULL) 'ifp' and 'ifa'.  The caller is responsible for
 * combining the results into an appropriate routing message.
 */
static void
rtsock_get_route(struct rt_msghdr * rtm, struct rtsock_rta * rta,
        union sockaddr_any * addr, union sockaddr_any * mask,
        union sockaddr_any * gateway, union sockaddr_any * ifp,
        union sockaddr_any * ifa, const struct route_entry * route,
        unsigned int type)
{
        struct ifdev *ifdev;
        unsigned int flags, use;

        route_get(route, addr, mask, gateway, ifp, ifa, &ifdev, &flags, &use);

        memset(rtm, 0, sizeof(*rtm));
        rtm->rtm_version = RTM_VERSION;
        rtm->rtm_type = type;
        rtm->rtm_flags = flags;
        rtm->rtm_index = ifdev_get_index(ifdev);
        rtm->rtm_use = use;

        rtsock_rta_init(rta);

        rtsock_rta_set(rta, RTAX_DST, addr, addr->sa.sa_len);

        if (!(flags & RTF_HOST)) {
                rtsock_compress_netmask(&mask->sa);

                rtsock_rta_set(rta, RTAX_NETMASK, mask, mask->sa.sa_len);
        }

        rtsock_rta_set(rta, RTAX_GATEWAY, gateway, gateway->sa.sa_len);

        if (ifp != NULL)
                rtsock_rta_set(rta, RTAX_IFP, ifp, ifp->sa.sa_len);

        if (ifa != NULL)
                rtsock_rta_set(rta, RTAX_IFA, ifa, ifa->sa.sa_len);
}

/*
 * Send a routing message about a route, with the given type which may be one
 * of RTM_ADD, RTM_CHANGE, RTM_DELETE, RTM_LOCK, and RTM_GET.  The routing
 * socket request information 'rtr', if not NULL, provides additional
 * information about the routing socket that was the source of the request (if
 * any), various fields that should be echoed, and (for RTM_GET) whether to
 * add interface information to the output.
 */
void
rtsock_msg_route(const struct route_entry * route, unsigned int type,
        const struct rtsock_request * rtr)
{
        union sockaddr_any addr, mask, gateway, ifp, ifa;
        struct rt_msghdr rtm;
        struct rtsock_rta rta;
        struct rtsock *rtsrc;
        struct pbuf *pbuf;
        int family, getif;

        rtsrc = (rtr != NULL) ? rtr->rtr_src : NULL;
        family = (route_is_ipv6(route)) ? AF_INET6 : AF_INET;

        if (!rtsock_msg_match(rtsrc, family, NULL /*pbuf*/))
                return;

        getif = (rtr != NULL && rtr->rtr_getif);

        rtsock_get_route(&rtm, &rta, &addr, &mask, &gateway,
            (getif) ? &ifp : NULL, (getif) ? &ifa : NULL, route, type);

        if (rtr != NULL) {
                rtm.rtm_flags |= RTF_DONE;
                rtm.rtm_pid = rtr->rtr_pid;
                rtm.rtm_seq = rtr->rtr_seq;
        }

        if (rtsock_rta_finalize(&rtm, sizeof(rtm), &rtm.rtm_msglen,
            &rtm.rtm_addrs, &rta, &pbuf, NULL, 0) > 0)
                rtsock_msg_match(rtsrc, family, pbuf);
}

/*
 * Generate sysctl(7) output or length for the given routing table entry
 * 'route', provided that the route passes the flags filter 'filter'.  The
 * address length 'addr_len' is used to compute a cheap length estimate.  On
 * success, return the byte size of the output.  If the route was not a match
 * for the filter, return zero.  On failure, return a negative error code.
 */
static ssize_t
rtsock_info_rtable_entry(const struct route_entry * route, unsigned int filter,
        socklen_t addr_len, struct rmib_oldp * oldp, size_t off)
{
        union sockaddr_any addr, mask, gateway;
        struct rt_msghdr rtm;
        struct rtsock_rta rta;
        unsigned int flags;
        ssize_t len;

        flags = route_get_flags(route);

        /* Apparently, matching any of the flags (if given) is sufficient. */
        if (filter != 0 && (filter & flags) != 0)
                return 0;

        /* Size (over)estimation shortcut. */
        if (oldp == NULL) {
                len = sizeof(rtm) + RT_ROUNDUP(addr_len) +
                    RT_ROUNDUP(sizeof(gateway));

                if (!(flags & RTF_HOST))
                        len += RT_ROUNDUP(addr_len);

                return len;
        }

        rtsock_get_route(&rtm, &rta, &addr, &mask, &gateway, NULL /*ifp*/,
            NULL /*ifa*/, route, RTM_GET);

        return rtsock_rta_finalize(&rtm, sizeof(rtm), &rtm.rtm_msglen,
            &rtm.rtm_addrs, &rta, NULL /*pbuf*/, oldp, off);
}

/*
 * Obtain routing table entries.
 */
static ssize_t
rtsock_info_rtable(struct rmib_oldp * oldp, int family, int filter)
{
        struct route_entry *route;
        ssize_t r, off;

        off = 0;

        if (family == AF_UNSPEC || family == AF_INET) {
                for (route = NULL; (route = route_enum_v4(route)) != NULL; ) {
                        if ((r = rtsock_info_rtable_entry(route,
                            (unsigned int)filter, sizeof(struct sockaddr_in),
                            oldp, off)) < 0)
                                return r;
                        off += r;
                }
        }

        if (family == AF_UNSPEC || family == AF_INET6) {
                for (route = NULL; (route = route_enum_v6(route)) != NULL; ) {
                        if ((r = rtsock_info_rtable_entry(route,
                            (unsigned int)filter, sizeof(struct sockaddr_in6),
                            oldp, off)) < 0)
                                return r;
                        off += r;
                }
        }

        /* TODO: should we add slack here? */
        return off;
}

/*
 * Generate routing socket data for an ARP table entry, for either routing
 * socket broadcasting or a sysctl(7) request.  The ARP table entry number is
 * given as 'num'.  The type of the message (RTM_) is given as 'type'.  The
 * resulting routing message header is stored in 'rtm' and an address vector is
 * stored in 'rta'.  The latter may point to addresses generated in 'addr' and
 * 'gateway'.  The caller is responsible for combining the results into an
 * appropriate routing message.
 */
static void
rtsock_get_arp(struct rt_msghdr * rtm, struct rtsock_rta * rta,
        struct sockaddr_in * addr, struct sockaddr_dlx * gateway,
        lldata_arp_num_t num, unsigned int type)
{
        struct ifdev *ifdev;
        unsigned int flags;

        lldata_arp_get(num, addr, gateway, &ifdev, &flags);

        memset(rtm, 0, sizeof(*rtm));
        rtm->rtm_version = RTM_VERSION;
        rtm->rtm_type = type;
        rtm->rtm_flags = flags;
        rtm->rtm_index = ifdev_get_index(ifdev);

        /* TODO: obtaining and reporting the proper expiry time, if any. */
        if (!(flags & RTF_STATIC))
                rtm->rtm_rmx.rmx_expire = (time_t)-1;

        rtsock_rta_init(rta);

        rtsock_rta_set(rta, RTAX_DST, addr, addr->sin_len);

        rtsock_rta_set(rta, RTAX_GATEWAY, gateway, gateway->sdlx_len);
}

/*
 * Send a routing message about an ARP table entry, with the given type which
 * may be one of RTM_ADD, RTM_CHANGE, RTM_DELETE, RTM_LOCK, and RTM_GET.  The
 * routing socket request information 'rtr', if not NULL, provides additional
 * information about the routing socket that was the source of the request (if
 * any) and various fields that should be echoed.
 */
void
rtsock_msg_arp(lldata_arp_num_t num, unsigned int type,
        const struct rtsock_request * rtr)
{
        struct sockaddr_in addr;
        struct sockaddr_dlx gateway;
        struct rt_msghdr rtm;
        struct rtsock_rta rta;
        struct pbuf *pbuf;

        assert(rtr != NULL);

        /*
         * We do not maintain the link-local tables ourselves, and thus, we do
         * not have a complete view of modifications to them.  In order not to
         * confuse userland with inconsistent updates (e.g., deletion of
         * previously unreported entries), send these routing messages to the
         * source of the routing request only.
         */
        if (!rtsock_msg_one(rtr->rtr_src, AF_INET, NULL /*pbuf*/))
                return;

        rtsock_get_arp(&rtm, &rta, &addr, &gateway, num, type);

        if (rtr != NULL) {
                rtm.rtm_flags |= RTF_DONE;
                rtm.rtm_pid = rtr->rtr_pid;
                rtm.rtm_seq = rtr->rtr_seq;
        }

        if (rtsock_rta_finalize(&rtm, sizeof(rtm), &rtm.rtm_msglen,
            &rtm.rtm_addrs, &rta, &pbuf, NULL, 0) > 0)
                rtsock_msg_one(rtr->rtr_src, AF_INET, pbuf);
}

/*
 * Obtain ARP table entries.
 */
static ssize_t
rtsock_info_lltable_arp(struct rmib_oldp * oldp)
{
        struct sockaddr_in addr;
        struct sockaddr_dlx gateway;
        struct rt_msghdr rtm;
        struct rtsock_rta rta;
        lldata_arp_num_t num;
        ssize_t r, off;

        off = 0;

        for (num = 0; lldata_arp_enum(&num); num++) {
                /* Size (over)estimation shortcut. */
                if (oldp == NULL) {
                        off += sizeof(struct rt_msghdr) +
                            RT_ROUNDUP(sizeof(addr)) +
                            RT_ROUNDUP(sizeof(gateway));

                        continue;
                }

                rtsock_get_arp(&rtm, &rta, &addr, &gateway, num, RTM_GET);

                if ((r = rtsock_rta_finalize(&rtm, sizeof(rtm),
                    &rtm.rtm_msglen, &rtm.rtm_addrs, &rta, NULL /*pbuf*/, oldp,
                    off)) < 0)
                        return r;
                off += r;
        }

        /* TODO: should we add slack here? */
        return off;
}

/*
 * Generate routing socket data for an NDP table entry, for either routing
 * socket broadcasting or a sysctl(7) request.  The NDP table entry number is
 * given as 'num'.  The type of the message (RTM_) is given as 'type'.  The
 * resulting routing message header is stored in 'rtm' and an address vector is
 * stored in 'rta'.  The latter may point to addresses generated in 'addr' and
 * 'gateway'.  The caller is responsible for combining the results into an
 * appropriate routing message.
 */
static void
rtsock_get_ndp(struct rt_msghdr * rtm, struct rtsock_rta * rta,
        struct sockaddr_in6 * addr, struct sockaddr_dlx * gateway,
        lldata_ndp_num_t num, unsigned int type)
{
        struct ifdev *ifdev;
        unsigned int flags;

        lldata_ndp_get(num, addr, gateway, &ifdev, &flags);

        memset(rtm, 0, sizeof(*rtm));
        rtm->rtm_version = RTM_VERSION;
        rtm->rtm_type = type;
        rtm->rtm_flags = flags;
        rtm->rtm_index = ifdev_get_index(ifdev);

        rtsock_rta_init(rta);

        rtsock_rta_set(rta, RTAX_DST, addr, addr->sin6_len);

        rtsock_rta_set(rta, RTAX_GATEWAY, gateway, gateway->sdlx_len);
}

/*
 * Send a routing message about an NDP table entry, with the given type which
 * may be one of RTM_ADD, RTM_CHANGE, RTM_DELETE, RTM_LOCK, and RTM_GET.  The
 * routing socket request information 'rtr', if not NULL, provides additional
 * information about the routing socket that was the source of the request (if
 * any) and various fields that should be echoed.
 */
void
rtsock_msg_ndp(lldata_ndp_num_t num, unsigned int type,
        const struct rtsock_request * rtr)
{
        struct sockaddr_in6 addr;
        struct sockaddr_dlx gateway;
        struct rt_msghdr rtm;
        struct rtsock_rta rta;
        struct pbuf *pbuf;

        assert(rtr != NULL);

        /*
         * We do not maintain the link-local tables ourselves, and thus, we do
         * not have a complete view of modifications to them.  In order not to
         * confuse userland with inconsistent updates (e.g., deletion of
         * previously unreported entries), send these routing messages to the
         * source of the routing request only.
         */
        if (!rtsock_msg_one(rtr->rtr_src, AF_INET6, NULL /*pbuf*/))
                return;

        rtsock_get_ndp(&rtm, &rta, &addr, &gateway, num, type);

        if (rtr != NULL) {
                rtm.rtm_flags |= RTF_DONE;
                rtm.rtm_pid = rtr->rtr_pid;
                rtm.rtm_seq = rtr->rtr_seq;
        }

        if (rtsock_rta_finalize(&rtm, sizeof(rtm), &rtm.rtm_msglen,
            &rtm.rtm_addrs, &rta, &pbuf, NULL, 0) > 0)
                rtsock_msg_one(rtr->rtr_src, AF_INET6, pbuf);
}

/*
 * Obtain NDP table entries.
 */
static ssize_t
rtsock_info_lltable_ndp(struct rmib_oldp * oldp)
{
        struct rt_msghdr rtm;
        struct rtsock_rta rta;
        struct sockaddr_in6 addr;
        struct sockaddr_dlx gateway;
        lldata_ndp_num_t num;
        ssize_t r, off;

        off = 0;

        for (num = 0; lldata_ndp_enum(&num); num++) {
                /* Size (over)estimation shortcut. */
                if (oldp == NULL) {
                        off += sizeof(struct rt_msghdr) +
                            RT_ROUNDUP(sizeof(addr)) +
                            RT_ROUNDUP(sizeof(gateway));

                        continue;
                }

                rtsock_get_ndp(&rtm, &rta, &addr, &gateway, num, RTM_GET);

                if ((r = rtsock_rta_finalize(&rtm, sizeof(rtm),
                    &rtm.rtm_msglen, &rtm.rtm_addrs, &rta, NULL /*pbuf*/, oldp,
                    off)) < 0)
                        return r;
                off += r;
        }

        /* TODO: should we add slack here? */
        return off;
}

/*
 * Obtain link-layer (ARP, NDP) table entries.
 */
static ssize_t
rtsock_info_lltable(struct rmib_oldp * oldp, int family)
{

        switch (family) {
        case AF_INET:
                return rtsock_info_lltable_arp(oldp);

        case AF_INET6:
                return rtsock_info_lltable_ndp(oldp);

        default:
                return 0;
        }
}

/*
 * Obtain link-layer address information for one specific interface.
 */
static ssize_t
rtsock_info_if_dl(struct ifdev * ifdev, struct ifa_msghdr * ifam,
        struct rmib_oldp * oldp, ssize_t off)
{
        struct rtsock_rta rta;
        struct sockaddr_dlx sdlx;
        ifaddr_dl_num_t num;
        ssize_t r, len;

        len = 0;

        for (num = 0; ifaddr_dl_enum(ifdev, &num); num++) {
                if (oldp == NULL) {
                        len += sizeof(*ifam) + RT_ROUNDUP(sizeof(sdlx));

                        continue;
                }

                rtsock_rta_init(&rta);

                rtsock_rta_add_dl(&rta, ifdev, num, &sdlx);

                if ((r = rtsock_rta_finalize(ifam, sizeof(*ifam),
                    &ifam->ifam_msglen, &ifam->ifam_addrs, &rta, NULL /*pbuf*/,
                    oldp, off + len)) < 0)
                        return r;
                len += r;
        }

        return len;
}

/*
 * Obtain IPv4 address information for one specific interface.
 */
static ssize_t
rtsock_info_if_v4(struct ifdev * ifdev, struct ifa_msghdr * ifam,
        struct rmib_oldp * oldp, ssize_t off)
{
        struct sockaddr_in sin[4];
        struct rtsock_rta rta;
        ifaddr_v4_num_t num;
        ssize_t r, len;

        len = 0;

        /*
         * Mostly for future compatibility, we support multiple IPv4 interface
         * addresses here.  Every interface has an interface address and a
         * netmask.  In addition, an interface may have either a broadcast or a
         * destination address.
         */
        for (num = 0; ifaddr_v4_enum(ifdev, &num); num++) {
                /* Size (over)estimation shortcut. */
                if (oldp == NULL) {
                        len += sizeof(*ifam) + RT_ROUNDUP(sizeof(sin[0])) * 3;

                        continue;
                }

                rtsock_rta_init(&rta);

                rtsock_rta_add_v4(&rta, ifdev, num, sin);

                if ((r = rtsock_rta_finalize(ifam, sizeof(*ifam),
                    &ifam->ifam_msglen, &ifam->ifam_addrs, &rta, NULL /*pbuf*/,
                    oldp, off + len)) < 0)
                        return r;
                len += r;
        }

        return len;
}

/*
 * Obtain IPv6 address information for one specific interface.
 */
static ssize_t
rtsock_info_if_v6(struct ifdev * ifdev, struct ifa_msghdr * ifam,
        struct rmib_oldp * oldp, ssize_t off)
{
        struct sockaddr_in6 sin6[3];
        struct rtsock_rta rta;
        ifaddr_v6_num_t num;
        ssize_t r, len;

        len = 0;

        /* As with IPv4, except that IPv6 has no broadcast addresses. */
        for (num = 0; ifaddr_v6_enum(ifdev, &num); num++) {
                /* Size (over)estimation shortcut. */
                if (oldp == NULL) {
                        len += sizeof(*ifam) + RT_ROUNDUP(sizeof(sin6[0])) * 3;

                        continue;
                }

                rtsock_rta_init(&rta);

                rtsock_rta_add_v6(&rta, ifdev, num, sin6);

                if ((r = rtsock_rta_finalize(ifam, sizeof(*ifam),
                    &ifam->ifam_msglen, &ifam->ifam_addrs, &rta, NULL /*pbuf*/,
                    oldp, off + len)) < 0)
                        return r;
                len += r;
        }

        return len;
}

/*
 * Obtain information for one specific interface.
 */
static ssize_t
rtsock_info_if(struct ifdev * ifdev, struct rmib_oldp * oldp, ssize_t off,
        int family)
{
        struct rtsock_rta rta;
        struct sockaddr_dlx sdlx;
        struct if_msghdr ifm;
        struct ifa_msghdr ifam;
        unsigned int ifflags;
        ssize_t r, len, sdlxsize;

        len = 0;

        ifflags = ifdev_get_ifflags(ifdev);

        /* Create an interface information entry. */
        rtsock_rta_init(&rta);

        if (oldp != NULL) {
                memset(&ifm, 0, sizeof(ifm));
                ifm.ifm_version = RTM_VERSION;
                ifm.ifm_type = RTM_IFINFO;
                ifm.ifm_flags = ifflags;
                ifm.ifm_index = ifdev_get_index(ifdev);
                memcpy(&ifm.ifm_data, ifdev_get_ifdata(ifdev),
                    sizeof(ifm.ifm_data));
        }

        /*
         * Generate a datalink socket address structure.  TODO: see if it is
         * worth obtaining just the length for the (oldp == NULL) case here.
         */
        memset(&sdlx, 0, sizeof(sdlx));

        ifaddr_dl_get(ifdev, 0, &sdlx);

        sdlxsize = RT_ROUNDUP(sdlx.sdlx_len);

        rtsock_rta_set(&rta, RTAX_IFP, &sdlx, sdlxsize);

        if ((r = rtsock_rta_finalize(&ifm, sizeof(ifm), &ifm.ifm_msglen,
            &ifm.ifm_addrs, &rta, NULL /*pbuf*/, oldp, off + len)) < 0)
                return r;
        len += r;

        /* Generate a header for all addresses once. */
        if (oldp != NULL) {
                memset(&ifam, 0, sizeof(ifam));
                ifam.ifam_version = RTM_VERSION;
                ifam.ifam_type = RTM_NEWADDR;
                ifam.ifam_flags = 0;
                ifam.ifam_index = ifdev_get_index(ifdev);
                ifam.ifam_metric = ifdev_get_metric(ifdev);
        }

        /* If requested and applicable, add any datalink addresses. */
        if (family == AF_UNSPEC || family == AF_LINK) {
                if ((r = rtsock_info_if_dl(ifdev, &ifam, oldp, off + len)) < 0)
                        return r;
                len += r;
        }

        /* If requested and applicable, add any IPv4 addresses. */
        if (family == AF_UNSPEC || family == AF_INET) {
                if ((r = rtsock_info_if_v4(ifdev, &ifam, oldp, off + len)) < 0)
                        return r;
                len += r;
        }

        /* If requested and applicable, add any IPv6 addresses. */
        if (family == AF_UNSPEC || family == AF_INET6) {
                if ((r = rtsock_info_if_v6(ifdev, &ifam, oldp, off + len)) < 0)
                        return r;
                len += r;
        }

        return len;
}

/*
 * Obtain interface information.
 */
static ssize_t
rtsock_info_iflist(struct rmib_oldp * oldp, int family, uint32_t ifindex)
{
        struct ifdev *ifdev;
        ssize_t r, off;

        /*
         * If information about a specific interface index is requested, then
         * return information for just that interface.
         */
        if (ifindex != 0) {
                if ((ifdev = ifdev_get_by_index(ifindex)) != NULL)
                        return rtsock_info_if(ifdev, oldp, 0, family);
                else
                        return 0;
        }

        /* Otherwise, iterate through the list of all interfaces. */
        off = 0;

        for (ifdev = ifdev_enum(NULL); ifdev != NULL;
            ifdev = ifdev_enum(ifdev)) {

                /* Avoid generating results that are never copied out. */
                if (oldp != NULL && !rmib_inrange(oldp, off))
                        oldp = NULL;

                if ((r = rtsock_info_if(ifdev, oldp, off, family)) < 0)
                        return r;

                off += r;
        }

        /* TODO: should we add slack here? */
        return off;
}

/*
 * Obtain routing table, ARP cache, and interface information through
 * sysctl(7).  Return the (produced, or if oldp is NULL, estimated) byte size
 * of the output on success, or a negative error code on failure.
 */
static ssize_t
rtsock_info(struct rmib_call * call, struct rmib_node * node __unused,
        struct rmib_oldp * oldp, struct rmib_newp * newp __unused)
{
        int family, filter;

        if (call->call_namelen != 3)
                return EINVAL;

        family = call->call_name[0];
        filter = call->call_name[2];

        switch (call->call_name[1]) {
        case NET_RT_FLAGS:
                /*
                 * Preliminary support for changes as of NetBSD 8, where by
                 * default, the use of this subcall implies an ARP/NDP-only
                 * request.
                 */
                if (filter == 0)
                        filter |= RTF_LLDATA;

                if (filter & RTF_LLDATA) {
                        if (family == AF_UNSPEC)
                                return EINVAL;

                        /*
                         * Split off ARP/NDP handling from the normal routing
                         * table listing, as done since NetBSD 8.  We generate
                         * the ARP/NDP listing from here, and keep those
                         * entries out of the routing table dump below.  Since
                         * the filter is of a match-any type, and we have just
                         * matched a flag, no further filtering is needed here.
                         */
                        return rtsock_info_lltable(oldp, family);
                }

                /* FALLTHROUGH */
        case NET_RT_DUMP:
                return rtsock_info_rtable(oldp, family, filter);

        case NET_RT_IFLIST:
                return rtsock_info_iflist(oldp, family, filter);

        default:
                return EINVAL;
        }
}