Remove building with NOCRYPTO option

[minix3.git] / minix / net / lwip / ifaddr.c

/* LWIP service - ifaddr.c - network interface address management */
/*
 * This module is an exception to the regular source organization of this
 * service, in that it manages part of another module's data structures, namely
 * ifdev.  As such, it should be seen as logically part of ifdev.  It is
 * separated only to keep the source code more manageable.  Still, this module
 * may use direct access only on the address-related fields of the ifdev
 * structure, so that those one day may be move into an ifaddr-specific
 * substructure within ifdev.
 */
/*
 * We manage three types of addresses here: IPv4 addresses (ifaddr_v4),
 * IPv6 addresses (ifaddr_v6), and link-layer a.k.a. MAC addresses (ifaddr_dl).
 *
 * Managing IPv4 addresses is easy.  lwIP supports only one IPv4 address per
 * netif.  While it would be possible to construct a model where one ifdev
 * consists of multiple netifs (with one IPv4 address each), we not support
 * this--mostly because it is a pain to keep state synchronized between the
 * netifs in that case.  Such support can still be added later; the IPv4 API
 * exposed from here does support multiple IPv4 addresses already just in case,
 * as does much of the code using the API.
 *
 * For IPv4 addresses we maintain only one extra piece of information here,
 * which is whether an IPv4 address has been set at all.  This is because for
 * our userland (DHCP clients in particular), we must allow assigning 0.0.0.0
 * as address to an interface.  We do not use the lwIP per-netif IPv4 gateway
 * field, nor the concept of a "default netif", in both cases because we
 * override all (routing) decisions that would use those settings.  lwIP does
 * not allow a broadcast address to be set, so support for broadcast addresses
 * is botched here: we disregard custom broadcast addresses given to us, and
 * instead expose the broadcast address that is used within lwIP.
 *
 * Managing IPv6 addresses is much more complicated.  First of all, even though
 * lwIP supports stateless address autoconfiguration (SLAAC) as per RFC 4862,
 * we disable that and instead make dhcpcd(8) responsible for all IPv6 address
 * configuration.  dhcpcd(8) will set addresses and routes as necessary, the
 * latter of which are used in lwIP through our routing hooks (in the route
 * module).  This approach, which is in line with where NetBSD is headed,
 * allows us to work around a number of lwIP limitations.  As a result we do
 * differ in this respect from NetBSD, which may switch between kernel-only,
 * dhcpcd-only, and hybrid autoconfiguration, mainly throught the accept_rtadv
 * sysctl(7) node.  Writing to this node has no real effect on MINIX 3.
 *
 * All IPv6 addresses have a prefix length, which is almost but not quite the
 * same as IPv4's subnet masks (see RFC 5942).  We must maintain the per-
 * address prefix length ourselves, as lwIP supports IPv6 prefix lengths of 64
 * bits only.  Our dhcpcd(8)-based approach allows us to work around that.
 *
 * All IPv6 addresses also have a state and a lifetime, both of which are
 * managed by lwIP.  Unlike for IPv4, address-derived routes and routing socket
 * messages are only created for addresses that are "valid", which means that
 * they are in either PREFERRED or DEPRECATED state.  This means that we have
 * to be aware of all address state transitions between "valid" and "not
 * valid", some of which (namely address duplication detection and lifetime
 * expirations) are initiated by lwIP.  As such, we need to keep shadow state
 * for each address, and use a callback to detect whether state has changed.
 *
 * For understanding of this module as well as lwIP, it is important to note
 * that "valid" is not the opposite of "invalid" in this context: "not valid"
 * includes the address states INVALID, DUPLICATED, and TENTATIVE, while
 * "invalid"/INVALID simply means that the address slot is free.
 *
 * Each IPv6 address also has associated flags.  We support an AUTOCONF flag
 * which indicates that no subnet route should be added for the address; on
 * MINIX 3, dhcpcd(8) is modified to pass in that flag when appropriate, thus
 * solving a problem that NetBSD suffers from, namely that it does not know
 * whether a userland-given route is static (implying a subnet) or auto-
 * configured (implying no subnet, again as per RFC 5942), leading to it doing
 * the wrong thing in dhcpcd-only autoconfiguration mode.  The TEMPORARY flag,
 * for privacy addresses (RFC 4941) should be the same as on NetBSD; it is
 * currently used only in source address selection (RFC 6724).  We override
 * lwIP's IPv6 source address selection algorithm to include support for not
 * just this flag, but also label and proper longest-common-prefix comparisons.
 * Finally, there is an HWBASED flag to make sure that when the link-layer
 * address is changed, the IPv6 link-local address is changed accordingly only
 * if the previous link-local address was also autogenerated from a link-layer
 * address and not set manually by userland.
 *
 * Finally, we support multiple link-layer addresses per interface, but only
 * because NetBSD's ifconfig(8) uses an API that expects such multi-address
 * support.  At any time, only one of the addresses is marked as "active",
 * which means it is used as MAC address in outgoing packets.  We support only
 * one MAC address per device driver, so the support for additional, inactive
 * link-layer addresses is there exclusively for ifconfig(8) interoperability.
 *
 * All interfaces, including those that do not have MAC addresses at all (e.g.,
 * loopback interfaces), do have one link-layer address.  This is expected in
 * particular by getifaddrs(3), which only recognizes interfaces that have a
 * link-layer address.
 *
 * Many features are still missing here, especially for IP addresses.  For
 * example, we do not yet support destination addresses at all yet, simply
 * because there is no interface type that uses them.  For IPv6, more work is
 * to be done to support proper netif status transitions versus address states,
 * fallout from address duplication, and various ND6_IFF_ flags.
 */

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

#include "lwip/etharp.h"

#include <netinet6/in6_var.h>
#include <netinet6/nd6.h>

/*
 * Routing flags for local address and local network routing entries.  This
 * may later have to be refined, for example in order not to set RTF_CLONING
 * for routes on interfaces that do not have link-layer addressing.
 *
 * IMPORTANT: as of NetBSD 8, RTF_CLONING has been renamed to RTF_CONNECTED.
 */
#define IFADDR_HOST_RTFLAGS     (RTF_UP | RTF_HOST | RTF_LOCAL)
#define IFADDR_NET_RTFLAGS      (RTF_UP | RTF_CLONING)

/* Address-related sysctl(7) settings. */
int ifaddr_auto_linklocal = 1;  /* different from NetBSD, see its usage */
int ifaddr_accept_rtadv = 0;    /* settable but completely disregarded */

/*
 * Initialize the local address administration for an interface that is in the
 * process of being created.
 */
void
ifaddr_init(struct ifdev * ifdev)
{
        unsigned int i;

        ifdev->ifdev_v4set = FALSE;

        for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++)
                ifdev->ifdev_v6state[i] = IP6_ADDR_INVALID;

        for (i = 0; i < __arraycount(ifdev->ifdev_hwlist); i++)
                ifdev->ifdev_hwlist[i].ifhwa_flags = 0;
}

/*
 * Find an IPv4 address locally assigned to a interface.  The IPv4 address is
 * given as 'addr'.  The interface is given as 'ifdev'.  On success, return OK,
 * with the IPv4 address number stored in 'num'.  On failure, return a negative
 * error code.
 */
int
ifaddr_v4_find(struct ifdev * ifdev, const struct sockaddr_in * addr,
        ifaddr_v4_num_t * num)
{
        ip_addr_t ipaddr;
        int r;

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

        if (!ifdev->ifdev_v4set ||
            !ip_addr_cmp(netif_ip_addr4(ifdev_get_netif(ifdev)), &ipaddr))
                return EADDRNOTAVAIL;

        *num = 0;
        return OK;
}

/*
 * Enumerate IPv4 addresses locally assigned to the given interface 'ifdev'.
 * The caller should set 'nump' to 0 initially, and increase it by one between
 * a successful call and the next enumeration call.  Return TRUE on success,
 * meaning that starting from the given value of 'nump' there is at least one
 * IPv4 address, of which the number is stored in 'nump' on return.  Return
 * FALSE if there are no more IPv4 addresses locally assigned to the interface.
 */
int
ifaddr_v4_enum(struct ifdev * ifdev, ifaddr_v4_num_t * num)
{

        /*
         * For now, we support only up to one IPv4 address per interface.
         * set if we are to return it.
         */
        return (*num == 0 && ifdev->ifdev_v4set);
}

/*
 * Obtain information about the IPv4 address 'num' assigned to the interface
 * 'ifdev'.  On success, return OK, with the IPv4 address stored in 'addr', the
 * network mask stored in 'mask', the broadcast stored in 'bcast', and the
 * destination address stored in 'dest'.  Each of these pointers may be NULL.
 * The interface may not have a broadcast and/or destination address; in that
 * case, their corresponding structures are not filled in at all, and thus must
 * be preinitialized by the caller to a default state.  The reason for not
 * zeroing them is that some callers use the same buffer for both.  On failure,
 * return a negative error code.
 */
int
ifaddr_v4_get(struct ifdev * ifdev, ifaddr_v4_num_t num,
        struct sockaddr_in * addr, struct sockaddr_in * mask,
        struct sockaddr_in * bcast, struct sockaddr_in * dest)
{
        const ip_addr_t *ipaddr, *netmask;
        struct netif *netif;
        ip_addr_t broad;
        socklen_t addr_len;

        if (!ifaddr_v4_enum(ifdev, &num))
                return EADDRNOTAVAIL;

        netif = ifdev_get_netif(ifdev);

        if (addr != NULL) {
                addr_len = sizeof(*addr);

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

        if (mask != NULL) {
                addr_len = sizeof(*mask);

                /*
                 * Do not bother using addr_put_netmask() here, as we would
                 * then first have to compute the prefix length..
                 */
                addr_put_inet((struct sockaddr *)mask, &addr_len,
                    netif_ip_netmask4(netif), TRUE /*kame*/, 0 /*port*/);
        }

        if (bcast != NULL) {
                if (netif->flags & NETIF_FLAG_BROADCAST) {
                        /* Fake a broadcast address. */
                        ipaddr = netif_ip_addr4(netif);
                        netmask = netif_ip_netmask4(netif);

                        ip_addr_set_ip4_u32(&broad,
                            ip_addr_get_ip4_u32(ipaddr) |
                            ~ip_addr_get_ip4_u32(netmask));

                        addr_len = sizeof(*bcast);

                        addr_put_inet((struct sockaddr *)bcast, &addr_len,
                            &broad, TRUE /*kame*/, 0 /*port*/);
                } else {
                        bcast->sin_len = 0;
                        bcast->sin_family = AF_UNSPEC;
                }
        }

        if (dest != NULL) {
                /* TODO: dest */
                dest->sin_len = 0;
                dest->sin_family = AF_UNSPEC;
        }

        return OK;
}

/*
 * Obtain NetBSD-style state flags (IN_IFF_) for the given local IPv4 address.
 * The given number must identify an existing address.  Return the flags.
 */
int
ifaddr_v4_get_flags(struct ifdev * ifdev, ifaddr_v4_num_t num)
{

        /* IPv4 per-address flags are not supported yet. */
        return 0;
}

/*
 * Determine whether there should be a local subnet route for the given
 * assigned IPv4 address, and if so, compute the subnet mask to add.  Return
 * TRUE if a local subnet route should be added, and return the network base
 * address in 'netbase' and the number of prefix bits in 'prefixp'.  Return
 * FALSE if no subnet route should be added for the assigned address.
 */
static unsigned int
ifaddr_v4_netroute(struct ifdev * ifdev, ifaddr_v4_num_t num,
        ip_addr_t * netbase, unsigned int * prefixp)
{
        const ip_addr_t *ipaddr, *netmask;
        unsigned int prefix;
        uint32_t val;

        /* Do not add subnet masks for loopback interfaces. */
        if (ifdev_is_loopback(ifdev))
                return FALSE;

        assert(num == 0);
        assert(ifdev->ifdev_v4set);

        ipaddr = netif_ip_addr4(ifdev_get_netif(ifdev));
        netmask = netif_ip_netmask4(ifdev_get_netif(ifdev));

        /*
         * If the subnet is a /32, skip adding a local host route: not only
         * would it not be useful, it would fail anyway because we currently do
         * not support adding a host-type route and a full-width net-type route
         * for the same IP address.
         */
        if (ip_addr_get_ip4_u32(netmask) == PP_HTONL(0xffffffffUL))
                return FALSE;

        /* Compute the network base address. */
        ip_addr_set_ip4_u32(netbase,
            ip_addr_get_ip4_u32(ipaddr) & ip_addr_get_ip4_u32(netmask));

        /* Find the number of prefix bits of the netmask.  TODO: improve.. */
        val = ntohl(ip_addr_get_ip4_u32(netmask));

        for (prefix = 0; prefix < IP4_BITS; prefix++)
                if (!(val & (1 << (IP4_BITS - prefix - 1))))
                        break;

        *prefixp = prefix;
        return TRUE;
}

/*
 * A local IPv4 address has been added to an interface.  The interface is given
 * as 'ifdev', and the number of the just-added IPv4 address is given as 'num'.
 * Generate a routing socket message and add local routes as appropriate.
 */
static void
ifaddr_v4_added(struct ifdev * ifdev, ifaddr_v4_num_t num)
{
        const ip_addr_t *ipaddr;
        ip_addr_t netbase;
        unsigned int prefix;

        assert(num == 0);
        assert(ifdev->ifdev_v4set);

        /* Report the addition of the interface address. */
        rtsock_msg_addr_v4(ifdev, RTM_NEWADDR, num);

        /*
         * Add the local host route.  This will always succeed: for addition,
         * we just checked with route_can_add(); when updating, we first remove
         * the exact same route.  For now, we forbid users from messing with
         * RTF_LOCAL routes directly, since nothing good (and a whole lot of
         * bad) can come out of that, so the routes will not change under us.
         *
         * Why are we not using lo0 for this route, like the BSDs do?  Because
         * that approach is not compatible with link-local addresses.  Instead,
         * we intercept outgoing traffic to the local address, and redirect it
         * over lo0, bypassing routing.  If we did not do this, we would never
         * know the originally intended zone of the outgoing packet.  As an
         * intended side effect, the traffic does show up on lo0 with BPF, just
         * like on BSDs.  Similarly, we do not need to set a gateway here.
         *
         * We currently do not use the routing tables for lookups on local
         * addresses - see ifaddr_v6_map() as to why.  If we ever do, that adds
         * another reason that the interface associated with the route must be
         * the interface that owns the address (and not, say, lo0).
         */
        ipaddr = netif_ip_addr4(ifdev_get_netif(ifdev));

        (void)route_add(ipaddr, IP4_BITS, NULL /*gateway*/, ifdev,
            IFADDR_HOST_RTFLAGS, NULL /*rtr*/);

        /*
         * Add the local network route, if the rules say that we should.  Even
         * then, adding the route may fail for various reasons, but this route
         * is not essential and so we ignore failures here.
         */
        if (ifaddr_v4_netroute(ifdev, num, &netbase, &prefix))
                (void)route_add(&netbase, prefix, NULL /*gateway*/, ifdev,
                    IFADDR_NET_RTFLAGS, NULL /*rtr*/);
}

/*
 * A particular local IPv4 address is being deleted.  See if there is another
 * local IPv4 address assigned to another interface that should have the same
 * local subnet route (but didn't, as such duplicate routes can obviously not
 * be added), and if so, readd the route for that other address.
 */
static void
ifaddr_v4_dupcheck(struct ifdev * oifdev, const ip_addr_t * onetbase,
        unsigned int oprefix)
{
        struct ifdev *ifdev;
        ip_addr_t netbase;
        unsigned int prefix;

        for (ifdev = NULL; (ifdev = ifdev_enum(ifdev)) != NULL; ) {
                if (ifdev == oifdev || !ifdev->ifdev_v4set)
                        continue;

                if (ifaddr_v4_netroute(ifdev, (ifaddr_v4_num_t)0, &netbase,
                    &prefix) && prefix == oprefix &&
                    ip_addr_cmp(&netbase, onetbase)) {
                        (void)route_add(&netbase, prefix, NULL /*gateway*/,
                            ifdev, IFADDR_NET_RTFLAGS, NULL /*rtr*/);

                        return;
                }
        }
}

/*
 * A local IPv4 address is about to be deleted from an interface, or the
 * interface itself is about to be destroyed.  Generate a routing socket
 * message about this and delete local routes as appropriate.  The interface is
 * given as 'ifdev', and the number of the IPv4 address that is about to be
 * deleted is given as 'num'.
 */
static void
ifaddr_v4_deleted(struct ifdev * ifdev, ifaddr_v4_num_t num)
{
        struct route_entry *route;
        ip_addr_t netbase;
        unsigned int prefix;

        assert(num == 0);
        assert(ifdev->ifdev_v4set);

        /* Delete the local network route, if we tried adding it at all. */
        if (ifaddr_v4_netroute(ifdev, num, &netbase, &prefix) &&
            (route = route_find(&netbase, prefix,
            FALSE /*is_host*/)) != NULL &&
            route_get_flags(route) == IFADDR_NET_RTFLAGS) {
                route_delete(route, NULL /*rtr*/);

                /*
                 * Readd the local network route for another interface, if that
                 * interface has a local address on the very same network.
                 */
                ifaddr_v4_dupcheck(ifdev, &netbase, prefix);
        }

        /* Delete the local host route. */
        if ((route = route_find(netif_ip_addr4(ifdev_get_netif(ifdev)),
            IP4_BITS, TRUE /*is_host*/)) != NULL)
                route_delete(route, NULL /*rtr*/);

        /* Report the deletion of the interface address. */
        rtsock_msg_addr_v4(ifdev, RTM_DELADDR, num);
}

/*
 * Add or update an IPv4 address on an interface.  The interface is given as
 * 'ifdev'.  The address to add or update is pointed to by 'addr', which must
 * always be a pointer to a valid address.  For DHCP clients it must be
 * possible to add the 'any' address (0.0.0.0).  The network mask, broadcast
 * address, and destination address parameters 'mask', 'bcast', and 'dest'
 * (respectively) may be NULL pointers or pointers to AF_UNSPEC addresses, and
 * will be disregarded if they are.  If 'mask' and/or 'bcast' are NULL when
 * adding an address, default values will be computed for them.  The 'flags'
 * field may contain NetBSD-style address flags (IN_IFF_).  Return OK if the
 * address was successfully added or updated, or a negative error code if not.
 */
int
ifaddr_v4_add(struct ifdev * ifdev, const struct sockaddr_in * addr,
        const struct sockaddr_in * mask, const struct sockaddr_in * bcast,
        const struct sockaddr_in * dest, int flags)
{
        ip_addr_t ipaddr, netmask, broad;
        ip4_addr_t ip4zero;
        struct netif *netif;
        unsigned int dummy;
        uint32_t val;
        int r;

        assert(addr != NULL);

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

        /* Forbid multicast (class D) and experimental (class E) addresses. */
        val = ntohl(ip_addr_get_ip4_u32(&ipaddr));

        if (ip_addr_ismulticast(&ipaddr) || IP_EXPERIMENTAL(val))
                return EINVAL;

        if (mask != NULL && mask->sin_family != AF_UNSPEC) {
                if ((r = addr_get_netmask((const struct sockaddr *)mask,
                    sizeof(*mask), IPADDR_TYPE_V4, &dummy, &netmask)) != OK)
                        return r;
        } else {
                /*
                 * Generate a netmask based on IP class.  Old, obsolete stuff,
                 * but we can't have no netmask.
                 */
                if (IN_CLASSA(val))
                        ip_addr_set_ip4_u32(&netmask, PP_HTONL(IN_CLASSA_NET));
                else if (IN_CLASSB(val))
                        ip_addr_set_ip4_u32(&netmask, PP_HTONL(IN_CLASSB_NET));
                else if (IN_CLASSC(val))
                        ip_addr_set_ip4_u32(&netmask, PP_HTONL(IN_CLASSC_NET));
                else /* should not trigger */
                        ip_addr_set_ip4_u32(&netmask, PP_HTONL(IN_CLASSD_NET));
        }

        if (bcast != NULL && bcast->sin_family != AF_UNSPEC) {
                if ((r = addr_get_inet((const struct sockaddr *)bcast,
                    sizeof(*bcast), IPADDR_TYPE_V4, &broad, TRUE /*kame*/,
                    NULL /*port*/)) != OK)
                        return r;

                /*
                 * lwIP does not allow setting the broadcast address, so we
                 * must ensure that the given address is what lwIP uses anyway.
                 * No need to perform byte order swaps here.
                 */
                if (ip_addr_get_ip4_u32(&broad) !=
                    (ip_addr_get_ip4_u32(&ipaddr) |
                    ~ip_addr_get_ip4_u32(&netmask)))
                        return EINVAL;
        }

        /* TODO: dest (note: may be NULL) */

        /*
         * We currently do not support any IPv4 address flags.  Even though
         * supporting them would make maintaining dhcpcd(8) easier, lwIP does
         * not offers the means to implement them properly.
         */
        if (flags != 0)
                return EINVAL;

        netif = ifdev_get_netif(ifdev);

        /* Should we add a new address, or update an existing one? */
        if (!ifdev->ifdev_v4set ||
            !ip_addr_cmp(netif_ip_addr4(netif), &ipaddr)) {
                /*
                 * Add a new address.  lwIP supports only one IPv4 address per
                 * netif.
                 */
                if (ifdev->ifdev_v4set)
                        return ENOBUFS; /* TODO: a better error code */

                /*
                 * It must be possible to add the address to the routing table,
                 * so make sure that we can add such a route later on.  The
                 * error code should be accurate for most real-world cases.
                 */
                if (!route_can_add(&ipaddr, IP4_BITS, TRUE /*is_host*/))
                        return EEXIST;

                ip4_addr_set_zero(&ip4zero);

                netif_set_addr(netif, ip_2_ip4(&ipaddr), ip_2_ip4(&netmask),
                    &ip4zero);

                ifdev->ifdev_v4set = TRUE;
        } else {
                /*
                 * Update an existing address.  First report the address as
                 * deleted.  Do not actually delete the address in netif,
                 * because that would cause problems with its changing IP
                 * addresses on existing sockets.
                 */
                ifaddr_v4_deleted(ifdev, (ifaddr_v4_num_t)0);

                /* Update the one part that may have actually changed. */
                netif_set_netmask(netif, ip_2_ip4(&netmask));
        }

        /* In both cases, we now need to report the address as added. */
        ifaddr_v4_added(ifdev, (ifaddr_v4_num_t)0);

        return OK;
}

/*
 * Delete an IPv4 address from an interface.  The given address number 'num'
 * must have been obtained from ifaddr_v4_find() or ifaddr_v4_enum() on the
 * same interface just before.  This function always succeeds.
 */
void
ifaddr_v4_del(struct ifdev * ifdev, ifaddr_v4_num_t num)
{
        ip4_addr_t ip4zero;

        assert(num == 0);
        assert(ifdev->ifdev_v4set);

        /*
         * Report the address as deleted.  Always do this first, because the
         * reporting requires that the address is still there.
         */
        ifaddr_v4_deleted(ifdev, num);

        /* Then actually delete the address. */
        ip4_addr_set_zero(&ip4zero);

        netif_set_addr(ifdev_get_netif(ifdev), &ip4zero, &ip4zero, &ip4zero);

        ifdev->ifdev_v4set = FALSE;
}

/*
 * Announce all IPv4 addresses associated with the given interface as deleted,
 * Used (only) right before the interface is destroyed.
 */
void
ifaddr_v4_clear(struct ifdev * ifdev)
{

        if (ifdev->ifdev_v4set)
                ifaddr_v4_deleted(ifdev, (ifaddr_v4_num_t)0);
}

/*
 * Return the first interface device that owns the given IPv4 address, or NULL
 * if it is not a valid local IPv4 address.
 */
struct ifdev *
ifaddr_v4_map_by_addr(const ip4_addr_t * ip4addr)
{
        struct ifdev *ifdev;

        /*
         * It would be nice to be able to do a route lookup on an RTF_LOCAL
         * entry here, but we do not do this for IPv6 either - see the comment
         * in ifaddr_v6_map() - and it is much less needed here, because each
         * interface has at most one IPv4 address.
         */
        for (ifdev = NULL; (ifdev = ifdev_enum(ifdev)) != NULL; ) {
                if (ifdev->ifdev_v4set &&
                    ip4_addr_cmp(netif_ip4_addr(ifdev_get_netif(ifdev)),
                    ip4addr))
                        return ifdev;
        }

        return NULL;
}

/*
 * Return the first interface device for which the given IPv4 address is on a
 * configured local subnet, or NULL if no match was found.
 */
static struct ifdev *
ifaddr_v4_map_by_subnet(const ip4_addr_t * ip4addr)
{
        struct ifdev *ifdev;
        struct netif *netif;
        uint32_t addr1, addr2, mask;

        addr1 = ip4_addr_get_u32(ip4addr);

        /*
         * Here, we must never do a route lookup, because this routine is used
         * for SO_DONTROUTE/MSG_DONTROUTE.
         */
        for (ifdev = NULL; (ifdev = ifdev_enum(ifdev)) != NULL; ) {
                if (!ifdev->ifdev_v4set)
                        continue;

                netif = ifdev_get_netif(ifdev);

                addr2 = ip4_addr_get_u32(netif_ip4_addr(netif));
                mask = ip4_addr_get_u32(netif_ip4_netmask(netif));

                if ((addr1 & mask) == (addr2 & mask))
                        return ifdev;
        }

        return NULL;
}

/*
 * Return TRUE if the given local IPv6 interface address is valid (= preferred
 * or deprecated), or FALSE if it is not (= tentative or duplicated).  The
 * address slot must be in use, that is, it must not be free (= invalid).
 */
static int
ifaddr_v6_isvalid(struct ifdev * ifdev, ifaddr_v6_num_t num)
{
        int state;

        state = ifdev->ifdev_v6state[num];

        /* Note that 'valid' and 'invalid' are not each other's inverse! */
        assert(!ip6_addr_isinvalid(state));

        return ip6_addr_isvalid(state);
}

/*
 * Find an IPv6 address assigned to the given interface that matches the given
 * IPv6 address.  Return TRUE if a match was found, with its number stored in
 * 'nump'.  Return FALSE if the address is not assigned to the interface.
 */
static int
ifaddr_v6_match(struct ifdev * ifdev, const ip_addr_t * ipaddr,
        ifaddr_v6_num_t * nump)
{
        int8_t i;

        assert(IP_IS_V6(ipaddr));

        i = netif_get_ip6_addr_match(ifdev_get_netif(ifdev), ip_2_ip6(ipaddr));
        if (i < 0)
                return FALSE;

        *nump = i;
        return TRUE;
}

/*
 * Find an IPv6 address locally assigned to a interface.  The IPv6 address is
 * given as 'addr6', and must use KAME-style embedding for zones.  The
 * interface is given as 'ifdev'.  On success, return OK, with the IPv6 address
 * number stored in 'num'.  On failure, return a negative error code.  This
 * function also returns tentative and duplicated addresses.
 */
int
ifaddr_v6_find(struct ifdev * ifdev, const struct sockaddr_in6 * addr6,
        ifaddr_v6_num_t * nump)
{
        ip_addr_t ipaddr;
        int r;

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

        if (ip6_addr_has_zone(ip_2_ip6(&ipaddr)) &&
            ip6_addr_zone(ip_2_ip6(&ipaddr)) != ifdev_get_index(ifdev))
                return EADDRNOTAVAIL;

        if (!ifaddr_v6_match(ifdev, &ipaddr, nump))
                return EADDRNOTAVAIL;

        return OK;
}

/*
 * Enumerate IPv6 addresses locally assigned to the given interface 'ifdev'.
 * The caller should set 'nump' to 0 initially, and increase it by one between
 * a successful call and the next enumeration call.  Return TRUE on success,
 * meaning that starting from the given value of 'nump' there is at least one
 * IPv6 address, of which the number is stored in 'nump' on return.  Return
 * FALSE if there are no more IPv6 addresses locally assigned to the interface.
 * This function also returns tentative and duplicated address entries.
 */
int
ifaddr_v6_enum(struct ifdev * ifdev, ifaddr_v6_num_t * nump)
{
        ifaddr_v6_num_t num;

        for (num = *nump; num < LWIP_IPV6_NUM_ADDRESSES; num++) {
                if (!ip6_addr_isinvalid(ifdev->ifdev_v6state[num])) {
                        *nump = num;
                        return TRUE;
                }
        }

        return FALSE;
}

/*
 * Obtain information about the IPv6 address 'num' assigned to the interface
 * 'ifdev'.  Store the IPv6 address in 'addr6', the network mask in 'mask6',
 * and the destination address in 'dest6'.  Each of these pointers may be NULL.
 * The returned addresses use KAME-style embedding for zones.  This function
 * also returns tentative and duplicated addresses.  It always succeeds.
 */
void
ifaddr_v6_get(struct ifdev * ifdev, ifaddr_v6_num_t num,
        struct sockaddr_in6 * addr6, struct sockaddr_in6 * mask6,
        struct sockaddr_in6 * dest6)
{
        struct netif *netif;
        socklen_t addr_len;

        /*
         * Due to route message generation upon address addition and deletion,
         * either the ifdev_v6state or the netif state may not yet have been
         * updated here.
         */
        assert(!ip6_addr_isinvalid(ifdev->ifdev_v6state[num]) ||
            !ip6_addr_isinvalid(netif_ip6_addr_state(ifdev_get_netif(ifdev),
            (int)num)));

        netif = ifdev_get_netif(ifdev);

        if (addr6 != NULL) {
                addr_len = sizeof(*addr6);

                (void)addr_put_inet((struct sockaddr *)addr6, &addr_len,
                    netif_ip_addr6(netif, (int)num), TRUE /*kame*/,
                    0 /*port*/);
        }

        if (mask6 != NULL) {
                addr_len = sizeof(*mask6);

                addr_put_netmask((struct sockaddr *)mask6, &addr_len,
                    IPADDR_TYPE_V6, ifdev->ifdev_v6prefix[num]);
        }

        if (dest6 != NULL) {
                /* TODO: dest6 */
                dest6->sin6_len = 0;
                dest6->sin6_family = AF_UNSPEC;
        }
}

/*
 * Obtain NetBSD-style state flags (IN6_IFF_) for the given local IPv6 address.
 * The given number must identify an existing address.  Return the flags.
 */
int
ifaddr_v6_get_flags(struct ifdev * ifdev, ifaddr_v6_num_t num)
{
        int state, flags;

        state = ifdev->ifdev_v6state[num];

        assert(!ip6_addr_isinvalid(state));

        flags = 0;
        if (ip6_addr_isduplicated(state))
                flags |= IN6_IFF_DUPLICATED;
        if (ip6_addr_istentative(state))
                flags |= IN6_IFF_TENTATIVE;
        if (ip6_addr_isdeprecated(state))
                flags |= IN6_IFF_DEPRECATED;
        if (ifdev->ifdev_v6flags[num] & IFADDR_V6F_AUTOCONF)
                flags |= IN6_IFF_AUTOCONF;
        if (ifdev->ifdev_v6flags[num] & IFADDR_V6F_TEMPORARY)
                flags |= IN6_IFF_TEMPORARY;

        return flags;
}

/*
 * Obtain lifetime information about the given local IPv6 address.  The given
 * 'lifetime' structure is filled as a result.  This function always succeeds.
 */
void
ifaddr_v6_get_lifetime(struct ifdev * ifdev, ifaddr_v6_num_t num,
        struct in6_addrlifetime * lifetime)
{
        struct netif *netif;
        uint32_t valid_life, pref_life;
        time_t now;

        assert(!ip6_addr_isinvalid(ifdev->ifdev_v6state[num]));

        netif = ifdev_get_netif(ifdev);

        valid_life = netif_ip6_addr_valid_life(netif, (int)num);
        pref_life = netif_ip6_addr_pref_life(netif, (int)num);

        /*
         * Represent 'static' as 'infinite' to userland.  This applies only to
         * link-local addresses, which do not have lifetimes at all.
         */
        if (ip6_addr_life_isstatic(valid_life)) {
                valid_life = IP6_ADDR_LIFE_INFINITE;
                pref_life = IP6_ADDR_LIFE_INFINITE;
        }

        now = clock_time(NULL);

        /*
         * TODO: the _vltime and _pltime values filled in here are not correct.
         * They should be set to the originally assigned values rather than the
         * current ones.  Getting this right would mean we'd have to save the
         * original values.  So far it does not look like userland needs that..
         */
        memset(lifetime, 0, sizeof(*lifetime));
        lifetime->ia6t_vltime = valid_life;
        lifetime->ia6t_pltime = pref_life;
        if (!ip6_addr_life_isinfinite(valid_life))
                lifetime->ia6t_expire = now + valid_life;
        if (!ip6_addr_life_isinfinite(pref_life))
                lifetime->ia6t_preferred = now + pref_life;
}

/*
 * Determine whether there should be a local subnet route for the given
 * assigned IPv6 address, and if so, compute the subnet mask to add.  Return
 * TRUE if a local subnet route should be added, and return the network base
 * address in 'netbase' and the number of prefix bits in 'prefixp'.  Return
 * FALSE if no subnet route should be added for the assigned address.
 */
static unsigned int
ifaddr_v6_netroute(struct ifdev * ifdev, ifaddr_v6_num_t num,
        ip_addr_t * netbase, unsigned int * prefixp)
{
        const ip_addr_t *ipaddr;

        ipaddr = netif_ip_addr6(ifdev_get_netif(ifdev), (int)num);

        /*
         * A local network route should be added only if all of the following
         * conditions are met:
         *
         * 1) The address is not auto-configured.  Autoconfigured addresses do
         *    not have an implied subnet, as explained in RFC 5942.
         *    Consistency with respect to subnet routes is why we do not allow
         *    changing the AUTOCONF flag after an address has been added.
         * 2) The subnet assignment is not a /128 prefix.  Not only would such
         *    a route not be useful, adding it would fail anyway because we
         *    currently do not support adding a host-type route and a
         *    full-width net-type route for the same IP address.
         * 3) If the interface is a loopback device, the address is not a link-
         *    local address.  This appears to be what NetBSD does, but
         *    additional loopback-related exceptions may be needed here.
         */
        if ((ifdev->ifdev_v6flags[num] & IFADDR_V6F_AUTOCONF) ||
            ifdev->ifdev_v6prefix[num] == IP6_BITS ||
            (ifdev_is_loopback(ifdev) &&
            ip6_addr_islinklocal(ip_2_ip6(ipaddr))))
                return FALSE;

        addr_normalize(netbase, ipaddr, ifdev->ifdev_v6prefix[num]);

        *prefixp = ifdev->ifdev_v6prefix[num];
        return TRUE;
}

/*
 * A local IPv6 has become valid (preferred or deprecated) after previously
 * being invalid (tentative, duplicated, or free).  Report the addition of the
 * now-usable address, and add appropriate routes to the IPv6 routing table.
 *
 * This function is *not* called immediately when an address is added, but
 * rather when the address becomes valid (meaning it is no longer tentative,
 * and thus supposedly collision-free).  For that reason, unlike for IPv4, this
 * function is only ever called indirectly, through the netif status callback.
 */
static void
ifaddr_v6_added(struct ifdev * ifdev, ifaddr_v6_num_t num)
{
        const ip_addr_t *ipaddr;
        ip_addr_t base;
        ip6_addr_t *base6;
        unsigned int prefix;

        /* Check the netif as ifdev_v6state is not yet updated here. */
        assert(!ip6_addr_isinvalid(netif_ip6_addr_state(ifdev_get_netif(ifdev),
            (int)num)));

        /* Report the addition of the interface address. */
        rtsock_msg_addr_v6(ifdev, RTM_NEWADDR, num);

        /*
         * Add the local host route.  This will always succeed.  See the IPv4
         * version of this code for more information.
         */
        ipaddr = netif_ip_addr6(ifdev_get_netif(ifdev), (int)num);

        (void)route_add(ipaddr, IP6_BITS, NULL /*gateway*/, ifdev,
            IFADDR_HOST_RTFLAGS, NULL /*rtr*/);

        /*
         * Add the local network route, if the rules say that we should.  Even
         * then, adding the route may fail for various reasons, but this route
         * is not essential and so we ignore failures here.
         */
        if (ifaddr_v6_netroute(ifdev, num, &base, &prefix))
                (void)route_add(&base, prefix, NULL /*gateway*/, ifdev,
                    IFADDR_NET_RTFLAGS, NULL /*rtr*/);

        /*
         * Add the node-local and link-local scope multicast routes.  These are
         * interface-specific rather than address-specific.  They are (re)added
         * for every address, and never deleted until interface destruction.
         */
        ip_addr_set_zero_ip6(&base);
        base6 = ip_2_ip6(&base);

        base6->addr[0] = htonl(0xff010000UL | ifdev_get_index(ifdev));

        (void)route_add(&base, 32, NULL /*gateway*/, ifdev, IFADDR_NET_RTFLAGS,
            NULL /*rtr*/);

        base6->addr[0] = htonl(0xff020000UL | ifdev_get_index(ifdev));

        (void)route_add(&base, 32, NULL /*gateway*/, ifdev, IFADDR_NET_RTFLAGS,
            NULL /*rtr*/);
}

/*
 * A particular local IPv6 address is being deleted.  See if there is another
 * local IPv6 address assigned that should have the same local subnet route
 * (but didn't, as such duplicate routes can obviously not be added), and if
 * so, readd the route for that other address, possibly for the same interface.
 */
static void
ifaddr_v6_dupcheck(struct ifdev * oifdev, const ip_addr_t * onetbase,
        unsigned int oprefix)
{
        struct ifdev *ifdev;
        ip_addr_t netbase;
        unsigned int prefix;
        ifaddr_v6_num_t num;

        for (ifdev = NULL; (ifdev = ifdev_enum(ifdev)) != NULL; ) {
                if (ifdev == oifdev)
                        continue;

                for (num = 0; num < LWIP_IPV6_NUM_ADDRESSES; num++) {
                        if (ip6_addr_isinvalid(ifdev->ifdev_v6state[num]) ||
                            !ifaddr_v6_isvalid(ifdev, num))
                                continue;

                        if (!ifaddr_v6_netroute(ifdev, num, &netbase, &prefix))
                                continue;

                        if (prefix != oprefix ||
                            !ip_addr_cmp(&netbase, onetbase))
                                continue;

                        (void)route_add(&netbase, prefix, NULL /*gateway*/,
                            ifdev, IFADDR_NET_RTFLAGS, NULL /*rtr*/);

                        return;
                }
        }
}

/*
 * A local IPv6 has become invalid (tentative, duplicated, or free) after
 * previously being valid (preferred or deprecated).  Report the deletion of
 * the previously-usable address, and remove previously added routes from the
 * IPv6 routing table.
 *
 * This function is not always called for every deleted address: instead, it is
 * called only when the address was previously valid, meaning that
 * ifaddr_v6_added() was invoked on it before as well.  Unlike for IPv4, this
 * function is typically called indirectly, through the netif status callback.
 */
static void
ifaddr_v6_deleted(struct ifdev * ifdev, ifaddr_v6_num_t num)
{
        struct route_entry *route;
        const ip_addr_t *ipaddr;
        ip_addr_t netbase;
        unsigned int prefix;

        assert(!ip6_addr_isinvalid(ifdev->ifdev_v6state[num]));

        ipaddr = netif_ip_addr6(ifdev_get_netif(ifdev), (int)num);

        /* Delete the local network route, if we tried adding it at all. */
        if (ifaddr_v6_netroute(ifdev, num, &netbase, &prefix) &&
            (route = route_find(&netbase, prefix,
            FALSE /*is_host*/)) != NULL &&
            route_get_flags(route) == IFADDR_NET_RTFLAGS) {
                route_delete(route, NULL /*rtr*/);

                /*
                 * Readd the local network route for another interface, if that
                 * interface has a local address on the very same network.
                 * Skip scoped (e.g., link-local) addresses, for which the
                 * routes are unique anyway.
                 */
                if (!ip6_addr_has_scope(ip_2_ip6(ipaddr), IP6_UNICAST))
                        ifaddr_v6_dupcheck(ifdev, &netbase, prefix);
        }

        /* Delete the local host route. */
        if ((route = route_find(ipaddr, IP6_BITS, TRUE /*is_host*/)) != NULL)
                route_delete(route, NULL /*rtr*/);

        /* Report the deletion of the interface address. */
        rtsock_msg_addr_v6(ifdev, RTM_DELADDR, num);
}

/*
 * Add or update an IPv6 address on an interface.  The interface is given as
 * 'ifdev'.  The IPv6 address to add or update is pointed to by 'addr6', which
 * must always be a pointer to a valid address.  The network mask is given as
 * 'mask6', but may be NULL when updating an address.  The same applies to the
 * destination address 'dest6'.  The given IPv6 address and destination address
 * must use KAME-style embedding for zones.  The flags field 'flags' contains
 * a set of NetBSD-style address flags (IN6_IFF_).  The 'lifetime' parameter
 * always points to lifetime information to be set or updated.  Return OK if
 * the address was successfully added or updated, or a negative error code
 * otherwise.
 */
int
ifaddr_v6_add(struct ifdev * ifdev, const struct sockaddr_in6 * addr6,
        const struct sockaddr_in6 * mask6, const struct sockaddr_in6 * dest6,
        int flags, const struct in6_addrlifetime * lifetime)
{
        ip_addr_t ipaddr;
        ip6_addr_t *ip6addr;
        struct netif *netif;
        unsigned int prefix;
        ifaddr_v6_num_t num;
        uint32_t valid_life;
        int r, state;

        netif = ifdev_get_netif(ifdev);

        /*
         * Somewhat curiously, NetBSD ignores the zone ID for these requests,
         * rather than rejecting requests with a zone ID that does not match
         * the associated interface's.  We have no reason to be stricter, and
         * so we overwrite whatever zone was given..
         */
        if ((r = addr_get_inet((const struct sockaddr *)addr6, sizeof(*addr6),
            IPADDR_TYPE_V6, &ipaddr, TRUE /*kame*/, NULL /*port*/)) != OK)
                return r;

        /*
         * Forbid locally-assigned multicast addresses.  Not only are those
         * absolutely disallowed in theory, we also assume all locally assigned
         * addresses are unicast in various places in practice.
         */
        if (ip_addr_ismulticast(&ipaddr))
                return EINVAL;

        ip6_addr_assign_zone(ip_2_ip6(&ipaddr), IP6_UNICAST, netif);

        /*
         * The netmask needs to be there only when adding a new address, but if
         * a netmask is given, it must be valid.  Note that lwIP itself
         * supports only /64 subnets; however, due to our custom routing hooks,
         * combined with giving lifetimes to all addresses (except the primary
         * link-local address, which is a /64), we control all routing
         * decisions that would otherwise be affected by that lwIP limitation.
         */
        if (mask6 != NULL && mask6->sin6_family != AF_UNSPEC) {
                if ((r = addr_get_netmask((const struct sockaddr *)mask6,
                    sizeof(*mask6), IPADDR_TYPE_V6, &prefix,
                    NULL /*ipaddr*/)) != OK)
                        return r;
        } else
                prefix = 0;

        /* TODO: dest6 (note: may be NULL) */

        /* TODO: support for IN6_IFF_ANYCAST and IN6_IFF_DETACHED. */
        if (flags & ~(IN6_IFF_TENTATIVE | IN6_IFF_DEPRECATED | IN6_IFF_NODAD |
            IN6_IFF_AUTOCONF | IN6_IFF_TEMPORARY))
                return EINVAL;

        /* Should we add a new address, or update an existing one? */
        ip6addr = ip_2_ip6(&ipaddr);

        if (!ifaddr_v6_match(ifdev, &ipaddr, &num)) {
                /* Add a new address. */
                if (prefix == 0)
                        return EINVAL;

                /*
                 * It must be possible to add the address to the routing table,
                 * so make sure that we can add such a route later on.  The
                 * error code should be accurate for most real-world cases.
                 */
                if (!route_can_add(&ipaddr, IP6_BITS, TRUE /*is_host*/))
                        return EEXIST;

                /*
                 * As an exception, if the given address is a link-local
                 * address and there is no link-local address in slot 0, use
                 * slot 0 to store this address.  This requires a /64 prefix
                 * length, because lwIP will use an implied /64 subnet for it.
                 */
                if (ip6_addr_isinvalid(ifdev->ifdev_v6state[0]) &&
                    ip6_addr_islinklocal(ip6addr) && prefix == 64) {
                        num = (ifaddr_v6_num_t)0;

                        /*
                         * Such link-local addresses are not considered to be
                         * autoconfigured, because they always have an implied
                         * subnet.  Therefore, clear that flag.
                         */
                        flags &= ~IN6_IFF_AUTOCONF;
                } else {
                        /*
                         * Find a free slot.  We bypass netif_ip6_addr_add() as
                         * it makes things more, rather than less, complicated
                         * for us here.
                         */
                        for (num = 1; num < LWIP_IPV6_NUM_ADDRESSES; num++) {
                                state = ifdev->ifdev_v6state[num];

                                if (ip6_addr_isinvalid(state))
                                        break;
                        }

                        if (num == LWIP_IPV6_NUM_ADDRESSES)
                                return ENOBUFS; /* TODO: a better error code */
                }

                assert(ip6_addr_isinvalid(netif_ip6_addr_state(netif, num)));

                /*
                 * We bypass the standard netif IPv6 address assignment
                 * functions here, because we may want to change the state of
                 * the address to something particular (rather than always
                 * tentative) and set the state only when we're otherwise done.
                 */
                netif->ip6_addr[num] = ipaddr;

                ifdev->ifdev_v6prefix[num] = prefix;

                /*
                 * New addresses are always DAD-tested for collisions first,
                 * except on loopback interfaces, which will simply get back
                 * its own DAD request and conclude there is a collision..
                 */
                if (flags & IN6_IFF_TENTATIVE)
                        state = IP6_ADDR_TENTATIVE;
                else if (flags & IN6_IFF_DEPRECATED)
                        state = IP6_ADDR_VALID;
                else if (ifdev_is_loopback(ifdev) || (flags & IN6_IFF_NODAD))
                        state = IP6_ADDR_PREFERRED;
                else
                        state = IP6_ADDR_TENTATIVE;

                ifdev->ifdev_v6flags[num] = 0;
                if (flags & IN6_IFF_AUTOCONF)
                        ifdev->ifdev_v6flags[num] |= IFADDR_V6F_AUTOCONF;
                if (flags & IN6_IFF_TEMPORARY)
                        ifdev->ifdev_v6flags[num] |= IFADDR_V6F_TEMPORARY;

                /* Precompute the address scope as well. */
                ifdev->ifdev_v6scope[num] =
                    addrpol_get_scope(&ipaddr, TRUE /*is_src*/);
        } else {
                /* Update an existing address. */
                /*
                 * Since no fundamental aspects about the address may change
                 * we also do not need to delete and readd the address here.
                 */
                if (prefix != 0 && prefix != ifdev->ifdev_v6prefix[num])
                        return EINVAL;

                /* TODO: figure out exactly what userland wants here.. */
                if (flags & IN6_IFF_TENTATIVE)
                        state = IP6_ADDR_TENTATIVE;
                else if (flags & IN6_IFF_DEPRECATED)
                        state = IP6_ADDR_VALID;
                else
                        state = IP6_ADDR_PREFERRED;

                /*
                 * Leave the AUTOCONF flag as is, because otherwise we might
                 * also have to add or delete a subnet route here.
                 */
                if (flags & IN6_IFF_TEMPORARY)
                        ifdev->ifdev_v6flags[num] |= IFADDR_V6F_TEMPORARY;
                else
                        ifdev->ifdev_v6flags[num] &= ~IFADDR_V6F_TEMPORARY;
        }

        /*
         * In our implementation, all addresses except the first link-local
         * address (which is always stored in slot 0) have a lifetime and are
         * thus not static as far as lwIP is concerned.  The result is that all
         * those addresses are considered to be /128 assignments, leaving the
         * routing decisions entirely to us, which is exactly what we want.  As
         * such we have to be careful not to assign a valid lifetime of 0
         * ("static").  For preferred lifetimes, 0 is not a special value,
         * though.  Either value may be 0xffffffff, which denotes "infinite".
         *
         * As for those routing decisions: we use the AUTOCONF flag as the
         * indication whether or not to add a subnet (= on-link prefix) route
         * for the address.  See also ifaddr_v6_added().
         */
        if (num != 0) {
                valid_life = lifetime->ia6t_vltime;
                if (ip6_addr_life_isstatic(valid_life))
                        valid_life++;
                netif_ip6_addr_set_valid_life(netif, (int)num, valid_life);
                netif_ip6_addr_set_pref_life(netif, (int)num,
                    lifetime->ia6t_pltime);
        }

        /*
         * The lifetime of address slot 0 is initialized to, and remains at all
         * times, zero ("static").  All other slots have an actual lifetime.
         */
        assert(netif_ip6_addr_isstatic(netif, (int)num) == !num);

        /*
         * Change the address state last, as this may immediately trigger
         * reports and route addition etc, although usually it will not:
         * addresses are typically added as tentative, and ifaddr_v6_added()
         * will be called only once the address is valid.
         */
        netif_ip6_addr_set_state(netif, (int)num, state);

        return OK;
}

/*
 * Delete an IPv6 address from an interface.  The given address number must
 * have been obtained through ifaddr_v6_find() or ifaddr_v6_enum().
 * This function always succeeds.
 */
void
ifaddr_v6_del(struct ifdev * ifdev, ifaddr_v6_num_t num)
{

        assert(num <= LWIP_IPV6_NUM_ADDRESSES);
        assert(!ip6_addr_isinvalid(ifdev->ifdev_v6state[num]));

        /* The state change will also trigger ifaddr_v6_deleted() if needed. */
        netif_ip6_addr_set_state(ifdev_get_netif(ifdev), (int)num,
            IP6_ADDR_INVALID);
}

/*
 * Announce all IPv6 addresses associated with the given interface as deleted.
 * Used (only) right before the interface is destroyed.
 */
void
ifaddr_v6_clear(struct ifdev * ifdev)
{
        ifaddr_v6_num_t num;

        for (num = 0; ifaddr_v6_enum(ifdev, &num); num++) {
                if (ifaddr_v6_isvalid(ifdev, num))
                        ifaddr_v6_deleted(ifdev, num);
        }
}

/*
 * Check state changes on local IPv6 addresses and update shadow state
 * accordingly.
 */
void
ifaddr_v6_check(struct ifdev * ifdev)
{
        struct netif *netif;
        ifaddr_v6_num_t num;
        int old_state, new_state, was_valid, is_valid;

        netif = ifdev_get_netif(ifdev);

        for (num = 0; num < LWIP_IPV6_NUM_ADDRESSES; num++) {
                /*
                 * Since we compile lwIP without support for stateless
                 * autoconfiguration, there will be no cases where new
                 * addresses appear out of nowhere.  As such, we can rely on
                 * all necessary fields already being initialized here.
                 */
                old_state = ifdev->ifdev_v6state[num];
                new_state = netif_ip6_addr_state(netif, num);

                if (old_state == new_state)
                        continue;

                was_valid = ip6_addr_isvalid(old_state);
                is_valid = ip6_addr_isvalid(new_state);

                if (was_valid != is_valid) {
                        if (is_valid)
                                ifaddr_v6_added(ifdev, num);
                        else
                                ifaddr_v6_deleted(ifdev, num);
                }

                ifdev->ifdev_v6state[num] = new_state;

                /*
                 * TODO: implement the requirements for dealing with duplicated
                 * addresses, in particular the link-local address, as
                 * specified by RFC 4862 Sec. 5.4.5.  NetBSD uses the
                 * ND6_IFF_IFDISABLED flag for this, essentially disabling
                 * the interface completely when that flag is set.
                 */
        }
}

/*
 * A change in the interface and/or link status has resulted in both now being
 * up.  Set the link-local address, if any, to tentative state.  Exempt
 * loopback interfaces, which would just see their own requests as collisions.
 *
 * TODO: the current implementation is the absolute minimum required for
 * dhcpcd(8) to function somewhat properly, but there is much more to be
 * decided and done when it comes to dealing with status changes..
 */
void
ifaddr_v6_set_up(struct ifdev * ifdev)
{

        if (!ifdev_is_loopback(ifdev) &&
            !ip6_addr_isinvalid(ifdev->ifdev_v6state[0]))
                netif_ip6_addr_set_state(ifdev_get_netif(ifdev), 0,
                    IP6_ADDR_TENTATIVE);
}

/*
 * Check whether all conditions are met for (re)assigning a link-local IPv6
 * address, and if so, do just that.
 */
void
ifaddr_v6_set_linklocal(struct ifdev * ifdev)
{

        /*
         * A few conditions must be met for link-local address assignment.
         * First of all, link-local address assignment must be enabled both
         * globally and on the interface.  The BSDs use the global setting as
         * an initial value for the link-local setting, but if we do this, it
         * would basically be impossible to change the global setting and have
         * any effect.  Thus, we use the global setting as an additional
         * requirement, with as reasoning that people will typically disable
         * the global setting in order to assign no IPv6 addresses at all.
         */
        if (!(ifdev_get_nd6flags(ifdev) & ND6_IFF_AUTO_LINKLOCAL) ||
            !ifaddr_auto_linklocal)
                return;

        /*
         * Second, the interface must be up.  This is an artificial requirement
         * that allows for the above settings to be changed at all: if we
         * assigned a link-local address as soon as we could (see below), this
         * would leave virtually no opportunity to change the settings.  Once
         * assigned, a link-local address is never removed automatically.
         */
        if (!ifdev_is_up(ifdev))
                return;

        /*
         * A proper (48-bit) hardware address must be set.  Interfaces without
         * hardware addresses (e.g., loopback devices) do not have this kind of
         * auto-assignment.  It may take a while for the driver to get back to
         * us with its initial hardware address, so wait for at least that.
         * Also update the link-local address upon subsequent (user-initiated)
         * changes to the hardware address, as long as if the IPv6 address has
         * not been overridden by userland by then.
         */
        if (ifdev_get_hwlen(ifdev) != ETHARP_HWADDR_LEN ||
            !(ifdev->ifdev_hwlist[0].ifhwa_flags & IFHWAF_VALID))
                return;

        if (!ip6_addr_isinvalid(ifdev->ifdev_v6state[0]) &&
            (ifdev->ifdev_v6flags[0] & IFADDR_V6F_HWBASED))
                return;

        /*
         * All conditions are met.  Set or replace the interface's IPv6
         * link-local address.  This uses the first IPv6 address slot, which
         * will be skipped when adding non-link-local addresses.  We first
         * delete the old address if any, in order to force invalidation of
         * bound sockets, because setting the new address does not (currently)
         * consider sockets.
         */
        if (!ip6_addr_isinvalid(ifdev->ifdev_v6state[0]))
                ifaddr_v6_del(ifdev, (ifaddr_v6_num_t)0);

#ifdef INET6
        ifdev->ifdev_v6flags[0] = IFADDR_V6F_HWBASED;
        ifdev->ifdev_v6prefix[0] = 64;
        netif_create_ip6_linklocal_address(ifdev_get_netif(ifdev),
            1 /*from_mac_48bit*/);
        assert(!ip6_addr_isinvalid(ifdev->ifdev_v6state[0]));

        ifdev->ifdev_v6scope[0] =
            addrpol_get_scope(netif_ip_addr6(ifdev_get_netif(ifdev), 0),
              TRUE /*is_src*/);
#endif /* INET6 */
}

/*
 * Return the first interface device that owns the given (non-any) IPv6
 * address, or NULL if it is not a valid local IPv6 address.  Addresses that
 * exist but are not usable ("usually assigned" in the RFC4862 sense) are
 * considered not valid in this context.
 */
struct ifdev *
ifaddr_v6_map_by_addr(const ip6_addr_t * ip6addr)
{
        struct ifdev *ifdev;
        struct netif *netif;
        ifaddr_v6_num_t num;

        /*
         * It would be nice to be able to do a route lookup on an RTF_LOCAL
         * entry here, but this approach would currently have two problems.
         *
         * 1) link-local addresses would require a lookup with a different
         *    embedded zone for each possible interface, requiring a loop over
         *    all interfaces after all; we could do a route lookup for global
         *    addresses only, but then there's also the issue that..
         * 2) once we get the interface from the route, we still have to check
         *    check the state of the address, as done below, and that requires
         *    us to go through all the interface addresses after all; we could
         *    embed the local address number in the RTF_LOCAL routing entry but
         *    that would get rather messy API-wise.
         *
         * Still, if it turns out that this function is a bottleneck, the above
         * workarounds should offer a way forward for the common case.
         */
        for (ifdev = NULL; (ifdev = ifdev_enum(ifdev)) != NULL; ) {
                netif = ifdev_get_netif(ifdev);

                for (num = 0; num < LWIP_IPV6_NUM_ADDRESSES; num++) {
                        if (ip6_addr_isinvalid(ifdev->ifdev_v6state[num]))
                                continue;

                        /*
                         * An address may be used as a local address only if it
                         * is preferred or deprecated, not if it is tentative
                         * or duplicated.
                         */
                        if (!ifaddr_v6_isvalid(ifdev, num))
                                continue;

                        /*
                         * Ignore the zone if the given address does not have
                         * one set.  Otherwise, the zone must match.
                         */
                        if (ip6_addr_cmp_zoneless(netif_ip6_addr(netif, num),
                            ip6addr) && (!ip6_addr_has_zone(ip6addr) ||
                            ip6_addr_test_zone(ip6addr, netif)))
                                return ifdev;
                }
        }

        return NULL;
}

/*
 * Return the first interface device for which the given IPv6 address is on a
 * configured local subnet, or NULL if no match was found.
 */
static struct ifdev *
ifaddr_v6_map_by_subnet(const ip_addr_t * ipaddr)
{
        const ip_addr_t *addr;
        struct ifdev *ifdev;
        struct netif *netif;
        ifaddr_v6_num_t num;
        unsigned int prefix;

        assert(IP_IS_V6(ipaddr));

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

                if (ip6_addr_has_zone(ip_2_ip6(ipaddr)) &&
                    !ip6_addr_test_zone(ip_2_ip6(ipaddr), netif))
                        continue;

                for (num = 0; num < LWIP_IPV6_NUM_ADDRESSES; num++) {
                        if (ip6_addr_isinvalid(ifdev->ifdev_v6state[num]))
                                continue;

                        if (!ifaddr_v6_isvalid(ifdev, num))
                                continue;

                        addr = netif_ip_addr6(netif, num);

                        /*
                         * For addresses with no implied subnet, check against
                         * the full address, so as to match only that address.
                         */
                        if (ifdev->ifdev_v6flags[num] & IFADDR_V6F_AUTOCONF)
                                prefix = IP6_BITS;
                        else
                                prefix = ifdev->ifdev_v6prefix[num];

                        if (addr_get_common_bits(ipaddr, addr, prefix) ==
                            prefix)
                                return ifdev;
                }
        }

        return NULL;
}

/*
 * Select an IPv6 source address for communication to the given destination
 * address on the given interface.  Return the selected source address, or NULL
 * if no appropriate source address could be found.  This function implements
 * RFC 6724 Sec. 5, and is very close to a drop-in replacement for lwIP's own
 * ip6_select_source_address() function.  We can do a slightly better job
 * because we have more information (for Rules 6 and 7) and can offer a more
 * complete, less lightweight implementation (for Rule 8).
 *
 * In summary, this is the implementation status of the rules:
 *
 * - Rules 1, 2, 3: fully implemented
 * - Rules 4, 5, 5.5: not applicable
 * - Rules 6, 7, 8: fully implemented
 *
 * Note that for rule 2, scope decisions are left to the addrpol module, which
 * makes a deliberate exception from the RFC for Unique-Local Addresses.
 *
 * The given destination address may not be properly zoned.
 */
static const ip_addr_t *
ifaddr_v6_select(struct ifdev * ifdev, const ip_addr_t * dest_addr)
{
        const ip_addr_t *cand_addr, *best_addr;
        int dest_scope, cand_scope, best_scope;
        int dest_label, cand_label, best_label = 0 /*gcc*/;
        uint8_t cand_pref, best_pref = 0 /*gcc*/;
        uint8_t cand_temp, best_temp = 0 /*gcc*/;
        int cand_bits, best_bits = 0 /*gcc*/;
        ifaddr_v6_num_t num, best_num;

        assert(ifdev != NULL);
        assert(IP_IS_V6(dest_addr));

        dest_scope = addrpol_get_scope(dest_addr, FALSE /*is_src*/);
        dest_label = -1; /* obtain only when necessary */

        best_addr = NULL;
        best_num = -1;

        for (num = 0; num < LWIP_IPV6_NUM_ADDRESSES; num++) {
                /* Consider only valid (preferred and deprecated) addresses. */
                if (!ip6_addr_isvalid(ifdev->ifdev_v6state[num]))
                        continue;

                cand_addr = netif_ip_addr6(ifdev_get_netif(ifdev), (int)num);

                /* Rule 1 */
                if (ip6_addr_cmp_zoneless(ip_2_ip6(cand_addr),
                    ip_2_ip6(dest_addr)))
                        return cand_addr;

                cand_scope = ifdev->ifdev_v6scope[num];
                cand_pref = ip6_addr_ispreferred(ifdev->ifdev_v6state[num]);
                cand_temp = (ifdev->ifdev_v6flags[num] & IFADDR_V6F_TEMPORARY);
                cand_label = -1;
                cand_bits = -1;

                /*
                 * The following monster of an if-condition relies on order of
                 * evaluation to obtain the more expensive-to-compute values
                 * only when strictly necessary.  We use a shortcut for Rule 6:
                 * labels are computed based on longest matching prefix, so if
                 * Rule 6 prefers the candidate address, Rule 8 would have
                 * preferred the candidate address as well.  Therefore, skip
                 * even computing labels when Rule 7 would not prefer either
                 * address, i.e. the "temporary" state of the candidate and the
                 * best address are equal.  For complete ties (which exist,
                 * because Rule 8 - longest common prefix - checks up to the
                 * subnet size), as "policy" we always pick the first address.
                 */
#define ADDRPOL_GET_LABEL(addr, label) \
        (label != -1 || (label = addrpol_get_label(addr), 1))
#define ADDR_GET_COMMON_BITS(addr1, addr2, num, bits) \
        (bits != -1 || (bits = (int) \
        addr_get_common_bits(addr1, addr2, ifdev->ifdev_v6prefix[num]), 1))

                if (best_addr == NULL || /* no alternative yet */
                    /* Rule 2 */
                    (cand_scope < best_scope && cand_scope >= dest_scope) ||
                    (cand_scope > best_scope && best_scope < dest_scope) ||
                    (cand_scope == best_scope &&
                    /* Rule 3 */
                    (cand_pref > best_pref || (cand_pref == best_pref &&
                    /* Rule 6 */
                    ((cand_temp != best_temp && /* shortcut, part 1 */
                    ADDRPOL_GET_LABEL(dest_addr, dest_label) &&
                    ADDRPOL_GET_LABEL(cand_addr, cand_label) &&
                    ADDRPOL_GET_LABEL(best_addr, best_label) &&
                    cand_label == dest_label && best_label != dest_label) ||
                    ((cand_temp == best_temp || /* shortcut, part 2 */
                    ((cand_label == dest_label) ==
                      (best_label == dest_label))) &&
                    /* Rule 7 */
                    (cand_temp > best_temp || (cand_temp == best_temp &&
                    /* Rule 8 */
                    ADDR_GET_COMMON_BITS(cand_addr, dest_addr, num,
                      cand_bits) &&
                    ADDR_GET_COMMON_BITS(best_addr, dest_addr, best_num,
                      best_bits) &&
                    cand_bits > best_bits)))))))) {
                        /* We found a new "winning" candidate. */
                        best_addr = cand_addr;
                        best_scope = cand_scope;
                        best_pref = cand_pref;
                        best_temp = cand_temp;
                        best_label = cand_label;
                        best_bits = cand_bits;
                        best_num = num;
                }
        }

        /* Return the best candidate, if any. */
        return best_addr;
}

/*
 * Pick an IPv6 source address locally assigned to the given interface, for use
 * with the given IPv6 destination address.  See ifaddr_v6_select() on why we
 * override lwIP's version of this function.
 *
 * This is a full replacement of the corresponding lwIP function, which should
 * be overridden with weak symbols, using patches against the lwIP source code.
 * As such, the lwIP headers should already provide the correct prototype for
 * this function.  If not, something will have changed in the lwIP
 * implementation, and this code must be revised accordingly.
 *
 * Important: there are currently no tests that will detect that overriding is
 * broken, since our test code (necessarily) uses the code path that calls
 * ifaddr_v6_select() directly, even though there are other places in the lwIP
 * source code that explicitly call this functions.
 */
const ip_addr_t *
ip6_select_source_address(struct netif * netif, const ip6_addr_t * dest_addr)
{
        ip_addr_t ipaddr;

        ip_addr_copy_from_ip6(ipaddr, *dest_addr);

        return ifaddr_v6_select(netif_get_ifdev(netif), &ipaddr);
}

/*
 * Find and return the interface to which the given address is assigned as a
 * local (source) address, or NULL if the given address is not a local address
 * for any interface.  The 'any' address as well as IPv4-mapped IPv6 addresses
 * are not supported and will yield NULL.
 */
struct ifdev *
ifaddr_map_by_addr(const ip_addr_t * ipaddr)
{

        switch (IP_GET_TYPE(ipaddr)) {
        case IPADDR_TYPE_V4:
                return ifaddr_v4_map_by_addr(ip_2_ip4(ipaddr));

        case IPADDR_TYPE_V6:
                if (ip6_addr_isipv4mappedipv6(ip_2_ip6(ipaddr)))
                        return NULL;

                return ifaddr_v6_map_by_addr(ip_2_ip6(ipaddr));

        case IPADDR_TYPE_ANY:
                return NULL;

        default:
                panic("unknown IP address type: %u", IP_GET_TYPE(ipaddr));
        }
}

/*
 * Find and return an interface that has a local network configured that
 * contains the given address, or NULL if there is no match.  If there are
 * multiple matches, an arbitrary one is returned.  The 'any' address as well
 * as IPv4-mapped IPv6 addresses are not supported and will yield NULL.
 */
struct ifdev *
ifaddr_map_by_subnet(const ip_addr_t * ipaddr)
{

        switch (IP_GET_TYPE(ipaddr)) {
        case IPADDR_TYPE_V4:
                return ifaddr_v4_map_by_subnet(ip_2_ip4(ipaddr));

        case IPADDR_TYPE_V6:
                if (ip6_addr_isipv4mappedipv6(ip_2_ip6(ipaddr)))
                        return NULL;

                return ifaddr_v6_map_by_subnet(ipaddr);

        case IPADDR_TYPE_ANY:
                return NULL;

        default:
                panic("unknown IP address type: %u", IP_GET_TYPE(ipaddr));
        }
}

/*
 * Select a local address to use as source address for the given destination
 * address.  If 'ifdev' is not NULL, it points to the interface from which to
 * select a source address.  If 'ifdev' is NULL, this function will attempt to
 * select an interface as well.  On success, return the selected source
 * address, and if 'ifdevp' is not NULL, store the selected interface in it.
 * On failure, return NULL.
 */
const ip_addr_t *
ifaddr_select(const ip_addr_t * dst_addr, struct ifdev * ifdev,
        struct ifdev ** ifdevp)
{
        struct route_entry *route;
        const ip6_addr_t *ip6addr;

        /*
         * If no interface is provided yet, start by determining the interface.
         * If the destination address has a zone, this step is easy.  Otherwise
         * we have to do a routing query on the destination address.
         */
        if (ifdev == NULL) {
                ip6addr = ip_2_ip6(dst_addr);

                if (IP_IS_V6(dst_addr) && ip6_addr_has_zone(ip6addr)) {
                        ifdev = ifdev_get_by_index(ip6_addr_zone(ip6addr));

                        if (ifdev == NULL)
                                return NULL;
                } else {
                        if ((route = route_lookup(dst_addr)) == NULL)
                                return NULL;

                        ifdev = route_get_ifdev(route);
                }
        }

        if (ifdevp != NULL)
                *ifdevp = ifdev;

        /*
         * We have found an interface.  Now select an IP address assigned to
         * that interface.  For IPv4, this is easy: each interface has only one
         * local address (if that).  For IPv6, we may have to select one of the
         * locally assigned addresses: global, link-local, etc.
         */
        switch (IP_GET_TYPE(dst_addr)) {
        case IPADDR_TYPE_V4:
                /* Use the IPv4 source address if one is set at all. */
                if (!ifdev->ifdev_v4set)
                        return FALSE;

                return netif_ip_addr4(ifdev_get_netif(ifdev));

        case IPADDR_TYPE_V6:
                return ifaddr_v6_select(ifdev, dst_addr);

        default:
                panic("unknown IP address type: %u", IP_GET_TYPE(dst_addr));
        }
}

/*
 * Check the given IPv6 address for a zone violation against the given
 * interface--that is, a scoped address leaving its original zone if used in
 * the context of the interface.  Return TRUE if the address is zone-
 * incompatible with the interface, and thus must not be used in packets sent
 * to that interface.  Return FALSE if there is no such zone incompatibility.
 */
int
ifaddr_is_zone_mismatch(const ip6_addr_t * ipaddr, struct ifdev * ifdev)
{

        /*
         * The IPv6 loopback address (::1) has an implicit link-local scope,
         * with a zone corresponding to the interface it is assigned to.  We
         * take a shortcut by assuming that the loopback address is assigned to
         * the primary loopback interface.
         */
        if (ip6_addr_isloopback(ipaddr))
                return (ifdev != ifdev_get_loopback());

        /* Zoned addresses must not leave their zone. */
        if (ip6_addr_has_zone(ipaddr))
                return !ip6_addr_test_zone(ipaddr, ifdev_get_netif(ifdev));

        return FALSE;
}

/*
 * Find a data link (hardware) address locally assigned to a interface.  The
 * address is given as 'addr', and the length of the memory area that contains
 * 'addr' is given as 'addr_len'.  The interface is given as 'ifdev'.  On
 * success, return OK, with the data link address number stored in 'num'.  For
 * interfaces that do not support hardware addresses, if the given address
 * provides a zero-length hardware address, always return successfully with 0
 * stored in 'nump'.  On failure, return a negative error code.
 */
int
ifaddr_dl_find(struct ifdev * ifdev, const struct sockaddr_dlx * addr,
        socklen_t addr_len, ifaddr_dl_num_t * nump)
{
        uint8_t hwaddr[NETIF_MAX_HWADDR_LEN];
        ifaddr_dl_num_t num;
        int r;

        if ((r = addr_get_link((const struct sockaddr *)addr, addr_len,
            NULL /*name*/, 0 /*name_max*/, hwaddr,
            ifdev_get_hwlen(ifdev))) != OK)
                return r;

        /*
         * For interfaces without hardware addresses, after passing the above
         * sanity checks (which guarantee that the searched-for address is of
         * zero length), return the pseudo-entry zero, which yields an entry
         * with a zero-sized hardware address once obtained.  This is required
         * for at least ifconfig(8).
         */
        if (ifdev->ifdev_ops->iop_set_hwaddr == NULL) {
                *nump = 0;
                return OK;
        }

        for (num = 0; (size_t)num < __arraycount(ifdev->ifdev_hwlist); num++) {
                if ((ifdev->ifdev_hwlist[num].ifhwa_flags & IFHWAF_VALID) &&
                    !memcmp(ifdev->ifdev_hwlist[num].ifhwa_addr, hwaddr,
                    ifdev_get_hwlen(ifdev))) {
                        *nump = num;
                        return OK;
                }
        }

        return EADDRNOTAVAIL;
}

/*
 * Enumerate data link (hardware) addresses locally assigned to the given
 * interface 'ifdev'.  The caller should set 'nump' to 0 initially, and
 * increase it by one between a successful call and the next enumeration call.
 * Return TRUE on success, meaning that starting from the given value of 'nump'
 * there is at least one data link address, of which the number is stored in
 * 'nump' on return.  Return FALSE if there are no more data link addresses
 * locally assigned to the interface.
 */
int
ifaddr_dl_enum(struct ifdev * ifdev, ifaddr_dl_num_t * num)
{

        /*
         * If hardware addresses are not supported, or if no hardware address
         * has been added to this interface yet (this shouldn't happen but
         * still), there is always one entry with a (zero-sized) address.
         * That is required for the IFP (name) entry as used by getifaddrs(3).
         */
        if (ifdev->ifdev_ops->iop_set_hwaddr == NULL ||
            !(ifdev->ifdev_hwlist[0].ifhwa_flags & IFHWAF_VALID))
                return (*num == 0);

        for (; (size_t)*num < __arraycount(ifdev->ifdev_hwlist); (*num)++) {
                if (ifdev->ifdev_hwlist[*num].ifhwa_flags & IFHWAF_VALID)
                        return TRUE;
        }

        return FALSE;
}

/*
 * Retrieve a data link (hardware) address for an interface.  For interfaces
 * that support hardware addresses, 'num' must be a number returned by
 * ifaddr_dl_find() or ifaddr_dl_enum().  For others, 'num' must be zero, and a
 * pseudo-address of zero size will be returned.  The address will be stored in
 * 'addr'.  This function always succeeds.
 */
void
ifaddr_dl_get(struct ifdev * ifdev, ifaddr_dl_num_t num,
        struct sockaddr_dlx * addr)
{
        const uint8_t *hwaddr;
        size_t hwaddr_len;
        socklen_t addr_len;

        if ((hwaddr_len = ifdev_get_hwlen(ifdev)) > 0) {
                /*
                 * Note that if we have no hardware addresses yet (which should
                 * not happen but still), the first entry may not be marked as
                 * valid yet.  Ignore it, and return an all-zeroes address.
                 */
                hwaddr = ifdev->ifdev_hwlist[num].ifhwa_addr;
        } else
                hwaddr = NULL;

        addr_len = sizeof(*addr);

        addr_put_link((struct sockaddr *)addr, &addr_len,
            ifdev_get_index(ifdev), ifdev_get_iftype(ifdev),
            ifdev_get_name(ifdev), hwaddr, hwaddr_len);
}

/*
 * Obtain NetBSD-style state flags (IFLR_) for the given local data link
 * address.  The given number may be 0, in which case that slot's state may not
 * be valid.  Otherwise, the given number must identify an existing address.
 * Return the flags, 0 if the slot was not valid.
 */
int
ifaddr_dl_get_flags(struct ifdev * ifdev, ifaddr_dl_num_t num)
{
        int flags;

        assert(num >= 0 && (size_t)num < __arraycount(ifdev->ifdev_hwlist));

        if (!(ifdev->ifdev_hwlist[num].ifhwa_flags & IFHWAF_VALID))
                return 0;

        flags = (num == 0) ? IFLR_ACTIVE : 0;

        if (ifdev->ifdev_hwlist[num].ifhwa_flags & IFHWAF_FACTORY)
                flags |= IFLR_FACTORY;

        return flags;
}

/*
 * Scan the list of hardware addresses of the given interface for a particular
 * hardware address, as well as for an available entry.  Return the entry found
 * or -1 if the given hardware address was not found.  Independently, return an
 * available entry in 'availp' or -1 if no entries are available.
 */
static ifaddr_dl_num_t
ifaddr_dl_scan(struct ifdev * ifdev, const uint8_t * hwaddr,
        ifaddr_dl_num_t * availp)
{
        ifaddr_dl_num_t num, found, avail;

        found = avail = -1;

        for (num = 0; (size_t)num < __arraycount(ifdev->ifdev_hwlist); num++) {
                if (!(ifdev->ifdev_hwlist[num].ifhwa_flags & IFHWAF_VALID)) {
                        if (avail == -1)
                                avail = num;
                } else if (!memcmp(ifdev->ifdev_hwlist[num].ifhwa_addr, hwaddr,
                    ifdev_get_hwlen(ifdev)))
                        found = num;
        }

        *availp = avail;
        return found;
}

/*
 * Set a hardware address entry in the hardware address list of the given
 * interface.
 */
static void
ifaddr_dl_set(struct ifdev * ifdev, ifaddr_dl_num_t num,
        const uint8_t * hwaddr, int is_factory)
{

        memcpy(&ifdev->ifdev_hwlist[num].ifhwa_addr, hwaddr,
            ifdev_get_hwlen(ifdev));

        ifdev->ifdev_hwlist[num].ifhwa_flags = IFHWAF_VALID;
        if (is_factory)
                ifdev->ifdev_hwlist[num].ifhwa_flags |= IFHWAF_FACTORY;

        rtsock_msg_addr_dl(ifdev, RTM_NEWADDR, num);
}

/*
 * Mark a new hardware address as active, after it has already been activated
 * on the hardware and in local administration.  The active slot is always slot
 * zero, so swap slots if needed.
 */
static void
ifaddr_dl_activate(struct ifdev * ifdev, ifaddr_dl_num_t num)
{
        struct ifdev_hwaddr tmp;
        struct netif *netif;
        size_t sz;

        assert(num != -1);

        /* The given slot may be zero if this is the initial address. */
        if (num != 0) {
                sz = sizeof(tmp);
                memcpy(&tmp, &ifdev->ifdev_hwlist[0], sz);
                memcpy(&ifdev->ifdev_hwlist[0], &ifdev->ifdev_hwlist[num], sz);
                memcpy(&ifdev->ifdev_hwlist[num], &tmp, sz);
        }

        netif = ifdev_get_netif(ifdev);

        /* Tell lwIP and routing sockets. */
        memcpy(&netif->hwaddr, &ifdev->ifdev_hwlist[0].ifhwa_addr,
            ifdev_get_hwlen(ifdev));

        rtsock_msg_addr_dl(ifdev, RTM_CHGADDR, 0);

        /* See if we can and should generate a link-local IPv6 address now. */
        ifaddr_v6_set_linklocal(ifdev);
}

/*
 * Add a data link (hardware) address to an interface, or if it already exists,
 * update its associated flags (IFLR_).
 */
int
ifaddr_dl_add(struct ifdev * ifdev, const struct sockaddr_dlx * addr,
        socklen_t addr_len, int flags)
{
        uint8_t hwaddr[NETIF_MAX_HWADDR_LEN];
        ifaddr_dl_num_t found, avail;
        int r;

        /*
         * If this interface type does not support setting hardware addresses,
         * refuse the call.  If the interface type supports it but the
         * underlying hardware does not, we cannot report failure here, though.
         * In that case, attempts to activate an address will fail instead.
         */
        if (ifdev->ifdev_ops->iop_set_hwaddr == NULL)
                return EINVAL;

        if ((r = addr_get_link((const struct sockaddr *)addr, addr_len,
            NULL /*name*/, 0 /*name_max*/, hwaddr,
            ifdev_get_hwlen(ifdev))) != OK)
                return r;

        /*
         * Find the slot for the given hardware address.  Also find the slot of
         * the active address, and a free slot.  All of these may not exist.
         */
        found = ifaddr_dl_scan(ifdev, hwaddr, &avail);

        if (found == -1) {
                if (avail == -1)
                        return ENOBUFS; /* TODO: a better error code */
                found = avail;
        }

        /*
         * If we are asked to activate this address, try that first: this may
         * fail if the network device does not support setting addresses, in
         * which case we want to fail without causing routing socket noise.
         */
        if ((flags & IFLR_ACTIVE) && found != 0 &&
            (r = ifdev->ifdev_ops->iop_set_hwaddr(ifdev, hwaddr)) != OK)
                return r;

        /*
         * If this is a new address, add and announce it.  Otherwise, just
         * update its flags.
         */
        if (found == avail) {
                ifaddr_dl_set(ifdev, found, hwaddr,
                    (flags & IFLR_FACTORY));
        } else {
                ifdev->ifdev_hwlist[found].ifhwa_flags &= ~IFLR_FACTORY;
                if (flags & IFLR_FACTORY)
                        ifdev->ifdev_hwlist[found].ifhwa_flags |= IFLR_FACTORY;
        }

        /*
         * Activate the address if requested, swapping slots as needed.  It is
         * not possible to deactivate the active address by changing its flags.
         */
        if ((flags & IFLR_ACTIVE) && found != 0)
                ifaddr_dl_activate(ifdev, found);

        return OK;
}

/*
 * Delete a data link (hardware) address from an interface.
 */
int
ifaddr_dl_del(struct ifdev * ifdev, ifaddr_dl_num_t num)
{

        if (ifdev->ifdev_ops->iop_set_hwaddr == NULL)
                return EINVAL;

        assert(num >= 0 && (size_t)num < __arraycount(ifdev->ifdev_hwlist));
        assert(ifdev->ifdev_hwlist[num].ifhwa_flags & IFHWAF_VALID);

        /* It is not possible to delete the active address. */
        if (num == 0)
                return EBUSY;

        rtsock_msg_addr_dl(ifdev, RTM_DELADDR, num);

        ifdev->ifdev_hwlist[num].ifhwa_flags = 0;

        return OK;
}

/*
 * Announce all data link (hardware) addresses associated with the given
 * interface as deleted, including the active address.  Used (only) right
 * before the interface is destroyed.
 */
void
ifaddr_dl_clear(struct ifdev * ifdev)
{
        ifaddr_dl_num_t num;

        /*
         * Do the active address last, because all announcements carry the
         * active address's hardware address as well.
         */
        for (num = 1; ifaddr_dl_enum(ifdev, &num); num++)
                rtsock_msg_addr_dl(ifdev, RTM_DELADDR, num);

        if (ifdev->ifdev_hwlist[0].ifhwa_flags & IFHWAF_VALID)
                rtsock_msg_addr_dl(ifdev, RTM_DELADDR, (ifaddr_dl_num_t)0);
}

/*
 * Update the interface's active hardware address.  If the 'is_factory' flag is
 * set, the address is the factory (driver-given) address.  This function may
 * only be called from ifdev_update_hwaddr().
 */
void
ifaddr_dl_update(struct ifdev * ifdev, const uint8_t * hwaddr, int is_factory)
{
        ifaddr_dl_num_t found, avail;

        /*
         * Find the slot for the given hardware address.  Also find the slot of
         * the active address, and a free slot.  All of these may not exist.
         */
        found = ifaddr_dl_scan(ifdev, hwaddr, &avail);

        /* If the given address is already the active one, do nothing. */
        if (found == 0) {
                /* Factory addresses are always added first! */
                assert(!is_factory);

                return;
        }

        if (found == -1) {
                /*
                 * If the given address is not in the list, add it.  If the
                 * list is full, first remove any non-active address.  The user
                 * won't like this, but it preserves correctness without too
                 * many complications, because this case is unlikely to happen.
                 */
                if (avail == -1) {
                        found = 1;

                        (void)ifaddr_dl_del(ifdev, found);
                } else
                        found = avail;

                ifaddr_dl_set(ifdev, found, hwaddr, is_factory);
        }

        ifaddr_dl_activate(ifdev, found);
}