Remove building with NOCRYPTO option

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

/* LWIP service - lldata.c - link-layer (ARP, NDP) data related routines */
/*
 * This module is largely isolated from the regular routing code.  There are
 * two reasons for that.  First, mixing link-layer routes with regular routes
 * would not work well due to the fact that lwIP keeps these data structures
 * entirely separate.  Second, as of version 8, NetBSD keeps the IP-layer and
 * link-layer routing separate as well.
 *
 * Unfortunately, lwIP does not provide much in the way of implementing the
 * functionality that would be expected for this module.  As such, the current
 * implementation is very restricted and simple.
 *
 * For ARP table entries, lwIP only allows for adding and deleting static
 * entries.  Non-static entries cannot be deleted.  Incomplete (pending)
 * entries cannot even be enumerated, nor can (e.g.) expiry information be
 * obtained.  The lwIP ARP datastructures are completely hidden, so there is no
 * way to overcome these limitations without changing lwIP itself.  As a
 * result, not all functionality of the arp(8) userland utility is supported.
 *
 * For NDP table entries, lwIP offers no API at all.  However, since the data
 * structures are exposed directly, we can use those to implement full support
 * for exposing information in a read-only way.  However, manipulating data
 * structures directly from here is too risky, nor does lwIP currently support
 * the concept of static NDP table entries.  Therefore, adding, changing, and
 * deleting NDP entries is currently not supported, and will also first require
 * changes to lwIP itself.
 *
 * The ndp(8) userland utility is also able to show and manipulate various
 * other neighbor discovery related tables and settings.  We support only a
 * small subset of them.  The main reason for this is that the other tables,
 * in particular the prefix and default router lists, are not relevant: on
 * MINIX 3, these are always managed fully in userland (usually dhcpcd(8)), and
 * we even hardcode lwIP not to parse Router Advertisement messages at all, so
 * even though those tables are still part of lwIP, they are always empty.
 * Other ndp(8) functionality are unsupported for similar reasons.
 */

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

#include "lwip/etharp.h"
#include "lwip/nd6.h"
#include "lwip/priv/nd6_priv.h" /* for neighbor_cache */

/*
 * Process a routing command specifically for an ARP table entry.  Return OK if
 * the routing command has been processed successfully and a routing socket
 * reply message has already been generated.  Return a negative error code on
 * failure, in which case the caller will generate a reply message instead.
 */
static int
lldata_arp_process(unsigned int type, const ip_addr_t * dst_addr,
        const struct eth_addr * gw_addr, struct ifdev * ifdev,
        unsigned int flags, const struct rtsock_request * rtr)
{
        const ip4_addr_t *ip4addr;
        struct eth_addr ethaddr, *ethptr;
        struct netif *netif;
        lldata_arp_num_t num;
        err_t err;

        netif = (ifdev != NULL) ? ifdev_get_netif(ifdev) : NULL;

        num = etharp_find_addr(netif, ip_2_ip4(dst_addr), &ethptr, &ip4addr);

        if (type != RTM_ADD && num < 0)
                return ESRCH;
        else if (type == RTM_ADD && num >= 0)
                return EEXIST;

        switch (type) {
        case RTM_CHANGE:
                /*
                 * This request is not used by arp(8), so keep things simple.
                 * For RTM_ADD we support only static entries; we support only
                 * those too here, and thus we can use delete-and-readd.  If
                 * the ethernet address is not being changed, try readding the
                 * entry with the previous ethernet address.
                 */
                if (gw_addr == NULL)
                        gw_addr = ethptr;

                if (etharp_remove_static_entry(ip_2_ip4(dst_addr)) != ERR_OK)
                        return EPERM;

                /* FALLTHROUGH */
        case RTM_ADD:
                assert(gw_addr != NULL);

                memcpy(&ethaddr, gw_addr, sizeof(ethaddr));

                /*
                 * Adding static, permanent, unpublished, non-proxy entries is
                 * all that lwIP supports right now.  We also do not get to
                 * specify the interface, and the way lwIP picks the interface
                 * may in fact result in a different one.
                 */
                if ((err = etharp_add_static_entry(ip_2_ip4(dst_addr),
                    &ethaddr)) != ERR_OK)
                        return util_convert_err(err);

                if ((num = etharp_find_addr(NULL /*netif*/, ip_2_ip4(dst_addr),
                    &ethptr, &ip4addr)) < 0)
                        panic("unable to find just-added static ARP entry");

                /* FALLTHROUGH */
        case RTM_LOCK:
        case RTM_GET:
                rtsock_msg_arp(num, type, rtr);

                return OK;

        case RTM_DELETE:
                memcpy(&ethaddr, ethptr, sizeof(ethaddr));

                if (etharp_remove_static_entry(ip_2_ip4(dst_addr)) != ERR_OK)
                        return EPERM;

                /*
                 * FIXME: the following block is a hack, because we cannot
                 * predict whether the above removal will succeed, while at the
                 * same time we need the entry to be present in order to report
                 * the deleted address to the routing socket.  We temporarily
                 * readd and then remove the entry just for the purpose of
                 * generating the routing socket reply.  There are other ways
                 * to resolve this, but only a better lwIP etharp API would
                 * allow us to resolve this problem cleanly.
                 */
                (void)etharp_add_static_entry(ip_2_ip4(dst_addr), &ethaddr);

                num = etharp_find_addr(NULL /*netif*/, ip_2_ip4(dst_addr),
                    &ethptr, &ip4addr);
                assert(num >= 0);

                rtsock_msg_arp(num, type, rtr);

                (void)etharp_remove_static_entry(ip_2_ip4(dst_addr));

                return OK;

        default:
                return EINVAL;
        }
}

/*
 * Enumerate ARP table entries.  Return TRUE if there is at least one more ARP
 * table entry, of which the number is stored in 'num'.  The caller should set
 * 'num' to 0 initially, and increase it by one between a successful call and
 * the next call.  Return FALSE if there are no more ARP table entries.
 */
int
lldata_arp_enum(lldata_arp_num_t * num)
{
        ip4_addr_t *ip4addr;
        struct netif *netif;
        struct eth_addr *ethaddr;

        for (; *num < ARP_TABLE_SIZE; ++*num) {
                if (etharp_get_entry(*num, &ip4addr, &netif, &ethaddr))
                        return TRUE;
        }

        return FALSE;
}

/*
 * Obtain information about the ARP table entry identified by 'num'.  The IPv4
 * address of the entry is stored in 'addr'.  Its ethernet address is stored in
 * 'gateway'.  The associated interface is stored in 'ifdevp', and the entry's
 * routing flags (RTF_) are stored in 'flagsp'.
 */
void
lldata_arp_get(lldata_arp_num_t num, struct sockaddr_in * addr,
        struct sockaddr_dlx * gateway, struct ifdev ** ifdevp,
        unsigned int * flagsp)
{
        ip_addr_t ipaddr;
        ip4_addr_t *ip4addr;
        struct netif *netif;
        struct ifdev *ifdev;
        struct eth_addr *ethaddr;
        socklen_t addr_len;

        if (!etharp_get_entry(num, &ip4addr, &netif, &ethaddr))
                panic("request for invalid ARP entry");

        ip_addr_copy_from_ip4(ipaddr, *ip4addr);

        assert(netif != NULL);
        ifdev = netif_get_ifdev(netif);

        addr_len = sizeof(*addr);

        addr_put_inet((struct sockaddr *)addr, &addr_len, &ipaddr,
            TRUE /*kame*/, 0 /*port*/);

        addr_len = sizeof(*gateway);

        addr_put_link((struct sockaddr *)gateway, &addr_len,
            ifdev_get_index(ifdev), ifdev_get_iftype(ifdev), NULL /*name*/,
            ethaddr->addr, sizeof(ethaddr->addr));

        *ifdevp = ifdev;

        /*
         * TODO: this is not necessarily accurate, but lwIP does not provide us
         * with information as to whether this is a static entry or not..
         */
        *flagsp = RTF_HOST | RTF_LLINFO | RTF_LLDATA | RTF_STATIC | RTF_CLONED;
}

/*
 * Obtain information about the ND6 neighbor cache entry 'i', which must be a
 * number between 0 (inclusive) and LWIP_ND6_NUM_NEIGHBORS (exclusive).  If an
 * entry with this number exists, return a pointer to its IPv6 address, and
 * additional information in each of the given pointers if not NULL.  The
 * associated interface is stored in 'netif'.  If the entry has an associated
 * link-layer address, a pointer to it is stored in 'lladdr'.  The entry's
 * state (ND6_{INCOMPLETE,REACHABLE,STALE,DELAY,PROBE}) is stored in 'state'.
 * The 'isrouter' parameter is filled with a boolean value indicating whether
 * the entry is for a router.  For ND6_INCOMPLETE and ND6_PROBE, the number of
 * probes sent so far is stored in 'probes_sent'; for other states, the value
 * is set to zero.  For ND6_REACHABLE and ND6_DELAY, the time until expiration
 * in ND6_TMR_INTERVAL-millisecond units is stored in 'expire_time'; for other
 * states, the value is set to zero.  If an entry with number 'i' does not
 * exist, NULL is returned.
 *
 * TODO: upstream this function to lwIP.
 */
static const ip6_addr_t *
nd6_get_neighbor_cache_entry(int8_t i, struct netif ** netif,
        const uint8_t ** lladdr, uint8_t * state, uint8_t * isrouter,
        uint32_t * probes_sent, uint32_t * expire_time)
{

        if (i < 0 || i >= LWIP_ND6_NUM_NEIGHBORS ||
            neighbor_cache[i].state == ND6_NO_ENTRY)
                return NULL;

        if (netif != NULL)
                *netif = neighbor_cache[i].netif;

        if (lladdr != NULL) {
                if (neighbor_cache[i].state != ND6_INCOMPLETE)
                        *lladdr = neighbor_cache[i].lladdr;
                else
                        *lladdr = NULL;
        }

        if (state != NULL)
                *state = neighbor_cache[i].state;

        if (isrouter != NULL)
                *isrouter = neighbor_cache[i].isrouter;

        if (probes_sent != NULL) {
                if (neighbor_cache[i].state == ND6_INCOMPLETE ||
                    neighbor_cache[i].state == ND6_PROBE)
                        *probes_sent = neighbor_cache[i].counter.probes_sent;
                else
                        *probes_sent = 0;
        }

        if (expire_time != NULL) {
                switch (neighbor_cache[i].state) {
                case ND6_REACHABLE:
                        *expire_time =
                            neighbor_cache[i].counter.reachable_time /
                            ND6_TMR_INTERVAL;
                        break;
                case ND6_DELAY:
                        *expire_time = neighbor_cache[i].counter.delay_time;
                        break;
                case ND6_INCOMPLETE:
                case ND6_PROBE:
                        /* Probes are sent once per timer tick. */
                        *expire_time = (LWIP_ND6_MAX_MULTICAST_SOLICIT + 1 -
                            neighbor_cache[i].counter.probes_sent) *
                            (ND6_TMR_INTERVAL / 1000);
                        break;
                default:
                        /* Stale entries do not expire; they get replaced. */
                        *expire_time = 0;
                        break;
                }
        }

        return &neighbor_cache[i].next_hop_address;
}

/*
 * Find a neighbor cache entry by IPv6 address.  Return its index number if
 * found, or -1 if not.  This is a reimplementation of the exact same function
 * internal to lwIP.
 *
 * TODO: make this function public in lwIP.
 */
static int8_t
nd6_find_neighbor_cache_entry(const ip6_addr_t * addr)
{
        int8_t i;

        for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) {
                if (ip6_addr_cmp(addr, &neighbor_cache[i].next_hop_address))
                        return i;
        }

        return -1;
}

/*
 * Find an NDP table entry based on the given interface and IPv6 address.  On
 * success, return OK, with the entry's index number stored in 'nump'.  On
 * failure, return an appropriate error code.
 */
int
lldata_ndp_find(struct ifdev * ifdev, const struct sockaddr_in6 * addr,
        lldata_ndp_num_t * nump)
{
        ip_addr_t ipaddr;
        int8_t i;
        int r;

        if ((r = addr_get_inet((const struct sockaddr *)addr, sizeof(*addr),
            IPADDR_TYPE_V6, &ipaddr, TRUE /*kame*/, NULL /*port*/)) != OK)
                return r;

        /*
         * For given link-local addresses, no zone may be provided in the
         * address at all.  In such cases, add the zone ourselves, using the
         * given interface.
         */
        if (ip6_addr_lacks_zone(ip_2_ip6(&ipaddr), IP6_UNKNOWN))
                ip6_addr_assign_zone(ip_2_ip6(&ipaddr), IP6_UNKNOWN,
                    ifdev_get_netif(ifdev));

        i = nd6_find_neighbor_cache_entry(ip_2_ip6(&ipaddr));
        if (i < 0)
                return ESRCH;

        /*
         * We should compare the neighbor cache entry's associated netif to
         * the given ifdev, but since the lwIP neighbor cache is currently not
         * keyed by netif anyway (i.e. the internal lookups are purely by IPv6
         * address as well), doing so makes little sense in practice.
         */

        *nump = (lldata_ndp_num_t)i;
        return OK;
}

/*
 * Process a routing command specifically for an NDP table entry.  Return OK if
 * the routing command has been processed successfully and a routing socket
 * reply message has already been generated.  Return a negative error code on
 * failure, in which case the caller will generate a reply message instead.
 */
static int
lldata_ndp_process(unsigned int type, const ip_addr_t * dst_addr,
        const struct eth_addr * gw_addr,
        struct ifdev * ifdev, unsigned int flags,
        const struct rtsock_request * rtr)
{
        lldata_ndp_num_t num;

        num = (lldata_ndp_num_t)
            nd6_find_neighbor_cache_entry(ip_2_ip6(dst_addr));

        if (type != RTM_ADD && num < 0)
                return ESRCH;
        else if (type == RTM_ADD && num >= 0)
                return EEXIST;

        switch (type) {
        case RTM_LOCK:
        case RTM_GET:
                rtsock_msg_arp(num, type, rtr);

                return OK;

        case RTM_ADD:
        case RTM_CHANGE:
        case RTM_DELETE:
                /* TODO: add lwIP support to implement these commands. */
                return ENOSYS;

        default:
                return EINVAL;
        }
}

/*
 * Enumerate NDP table entries.  Return TRUE if there is at least one more NDP
 * table entry, of which the number is stored in 'num'.  The caller should set
 * 'num' to 0 initially, and increase it by one between a successful call and
 * the next call.  Return FALSE if there are no more NDP table entries.
 */
int
lldata_ndp_enum(lldata_ndp_num_t * num)
{

        for (; *num < LWIP_ND6_NUM_NEIGHBORS; ++*num) {
                if (nd6_get_neighbor_cache_entry(*num, NULL /*netif*/,
                    NULL /*lladdr*/, NULL /*state*/, NULL /*isrouter*/,
                    NULL /*probes_sent*/, NULL /*expire_time*/) != NULL)
                        return TRUE;
        }

        return FALSE;
}

/*
 * Obtain information about the NDP table entry identified by 'num'.  The IPv6
 * address of the entry is stored in 'addr'.  Its ethernet address is stored in
 * 'gateway'.  The associated interface is stored in 'ifdevp', and the entry's
 * routing flags (RTF_) are stored in 'flagsp'.
 */
void
lldata_ndp_get(lldata_ndp_num_t num, struct sockaddr_in6 * addr,
        struct sockaddr_dlx * gateway, struct ifdev ** ifdevp,
        unsigned int * flagsp)
{
        const ip6_addr_t *ip6addr;
        ip_addr_t ipaddr;
        struct netif *netif = NULL /*gcc*/;
        struct ifdev *ifdev;
        const uint8_t *lladdr = NULL /*gcc*/;
        socklen_t addr_len;

        ip6addr = nd6_get_neighbor_cache_entry(num, &netif, &lladdr,
            NULL /*state*/, NULL /*isrouter*/, NULL /*probes_sent*/,
            NULL /*expire_time*/);
        assert(ip6addr != NULL);

        ip_addr_copy_from_ip6(ipaddr, *ip6addr);

        ifdev = netif_get_ifdev(netif);
        assert(ifdev != NULL);

        addr_len = sizeof(*addr);

        addr_put_inet((struct sockaddr *)addr, &addr_len, &ipaddr,
            TRUE /*kame*/, 0 /*port*/);

        addr_len = sizeof(*gateway);

        addr_put_link((struct sockaddr *)gateway, &addr_len,
            ifdev_get_index(ifdev), ifdev_get_iftype(ifdev), NULL /*name*/,
            lladdr, ifdev_get_hwlen(ifdev));

        *ifdevp = ifdev;
        *flagsp = RTF_HOST | RTF_LLINFO | RTF_LLDATA | RTF_CLONED;
}

/*
 * Obtain information about the NDP table entry with the number 'num', which
 * must be obtained through a previous call to lldata_ndp_find().  On return,
 * 'asked' is filled with the number of probes sent so far (0 if inapplicable),
 * 'isrouter' is set to 1 or 0 depending on whether the entry is for a router,
 * 'state' is set to the entry's state (ND6_LLINFO_), and 'expire' is set to
 * either the UNIX timestamp of expiry for the entry; 0 for permanent entries.
 * None of the given pointers must be NULL.  This function always succeeds.
 */
void
lldata_ndp_get_info(lldata_ndp_num_t num, long * asked, int * isrouter,
        int * state, int * expire)
{
        uint32_t nd6_probes_sent = 0 /*gcc*/, nd6_expire_time = 0 /*gcc*/;
        uint8_t nd6_state = 0 /*gcc*/, nd6_isrouter = 0 /*gcc*/;

        (void)nd6_get_neighbor_cache_entry(num, NULL /*netif*/,
            NULL /*lladdr*/, &nd6_state, &nd6_isrouter, &nd6_probes_sent,
            &nd6_expire_time);

        *asked = (long)nd6_probes_sent;

        *isrouter = !!nd6_isrouter;

        switch (nd6_state) {
        case ND6_INCOMPLETE:    *state = ND6_LLINFO_INCOMPLETE; break;
        case ND6_REACHABLE:     *state = ND6_LLINFO_REACHABLE; break;
        case ND6_STALE:         *state = ND6_LLINFO_STALE; break;
        case ND6_DELAY:         *state = ND6_LLINFO_DELAY; break;
        case ND6_PROBE:         *state = ND6_LLINFO_PROBE; break;
        default:                panic("unknown ND6 state %u", nd6_state);
        }

        if (nd6_expire_time != 0)
                *expire = clock_time(NULL) +
                    (int)nd6_expire_time * (ND6_TMR_INTERVAL / 1000);
        else
                *expire = 0;
}

/*
 * Process a routing command specifically for a link-layer route, as one of the
 * specific continuations of processing started by route_process().  The RTM_
 * routing command is given as 'type'.  The route destination is given as
 * 'dst_addr'; its address type determines whether the operation is for ARP or
 * NDP.  The sockaddr structure for 'gateway' is passed on as is and may have
 * to be parsed here if not NULL.  'ifdev' is the interface to be associated
 * with the route; it is non-NULL only if an interface name (IFP) or address
 * (IFA) was given.  The RTF_ flags field has been checked against the globally
 * supported flags, but may have to be checked for flags that do not apply to
 * ARP/NDP routes.  Return OK or a negative error code, following the same
 * semantics as route_process().
 */
int
lldata_process(unsigned int type, const ip_addr_t * dst_addr,
        const struct sockaddr * gateway, struct ifdev * ifdev,
        unsigned int flags, const struct rtsock_request * rtr)
{
        const struct route_entry *route;
        struct eth_addr ethaddr, *gw_addr;
        int r;

        assert(flags & RTF_LLDATA);

        /*
         * It seems that RTF_UP does not apply to link-layer routing entries.
         * We basically accept any flags that we can return, but we do not
         * actually check most of them anywhere.
         */
        if ((flags & ~(RTF_HOST | RTF_LLINFO | RTF_LLDATA | RTF_STATIC |
           RTF_CLONED | RTF_ANNOUNCE)) != 0)
                return EINVAL;

        gw_addr = NULL;

        if (type == RTM_ADD || type == RTM_CHANGE) {
                /*
                 * Link-layer entries are always host entries.  Not all
                 * requests pass in this flag though, so check only when the
                 * flags are supposed to be set.
                 */
                if ((type == RTM_ADD || type == RTM_CHANGE) &&
                    !(flags & RTF_HOST))
                        return EINVAL;

                /* lwIP does not support publishing custom entries. */
                if (flags & RTF_ANNOUNCE)
                        return ENOSYS;

                /* RTF_GATEWAY is always cleared for link-layer entries. */
                if (gateway != NULL) {
                        if ((r = addr_get_link(gateway, gateway->sa_len,
                            NULL /*name*/, 0 /*name_max*/, ethaddr.addr,
                            sizeof(ethaddr.addr))) != OK)
                                return r;

                        gw_addr = &ethaddr;
                }

                if (type == RTM_ADD) {
                        if (gateway == NULL)
                                return EINVAL;

                        /*
                         * If no interface has been specified, see if the
                         * destination address is on a locally connected
                         * network.  If so, use that network's interface.
                         * Otherwise reject the request altogether: we must
                         * have an interface to which to associate the entry.
                         */
                        if (ifdev == NULL) {
                                if ((route = route_lookup(dst_addr)) != NULL &&
                                    !(route_get_flags(route) & RTF_GATEWAY))
                                        ifdev = route_get_ifdev(route);
                                else
                                        return ENETUNREACH;
                        }
                }
        }

        if (IP_IS_V4(dst_addr))
                return lldata_arp_process(type, dst_addr, gw_addr, ifdev,
                    flags, rtr);
        else
                return lldata_ndp_process(type, dst_addr, gw_addr, ifdev,
                    flags, rtr);
}