Remove building with NOCRYPTO option

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

/* LWIP service - addr.c - socket address verification and conversion */

#include "lwip.h"

/*
 * Return TRUE if the given socket address is of type AF_UNSPEC, or FALSE
 * otherwise.
 */
int
addr_is_unspec(const struct sockaddr * addr, socklen_t addr_len)
{

        return (addr_len >= offsetof(struct sockaddr, sa_data) &&
            addr->sa_family == AF_UNSPEC);
}

/*
 * Check whether the given multicast address is generally valid.  This check
 * should not be moved into addr_get_inet(), as we do not want to forbid
 * creating routes for such addresses, for example.  We do however apply the
 * restrictions here to all provided source and destination addresses.  Return
 * TRUE if the address is an acceptable multicast address, or FALSE otherwise.
 */
int
addr_is_valid_multicast(const ip_addr_t * ipaddr)
{
        uint8_t scope;

        assert(ip_addr_ismulticast(ipaddr));

        /* We apply restrictions to IPv6 multicast addresses only. */
        if (IP_IS_V6(ipaddr)) {
                scope = ip6_addr_multicast_scope(ip_2_ip6(ipaddr));

                if (scope == IP6_MULTICAST_SCOPE_RESERVED0 ||
                    scope == IP6_MULTICAST_SCOPE_RESERVEDF)
                        return FALSE;

                /*
                 * We do not impose restrictions on the three defined embedded
                 * flags, even though we put no effort into supporting them,
                 * especially in terms of automatically creating routes for
                 * all cases.  We do force the fourth flag to be zero.
                 * Unfortunately there is no lwIP macro to check for this flag.
                 */
                if (ip_2_ip6(ipaddr)->addr[0] & PP_HTONL(0x00800000UL))
                        return FALSE;

                /* Prevent KAME-embedded zone IDs from entering the system. */
                if (ip6_addr_has_scope(ip_2_ip6(ipaddr), IP6_UNKNOWN) &&
                    (ip_2_ip6(ipaddr)->addr[0] & PP_HTONL(0x0000ffffUL)))
                        return FALSE;
        }

        return TRUE;
}

/*
 * Load a sockaddr structure, as copied from userland, as a lwIP-style IP
 * address and (optionally) a port number.  The expected type of IP address is
 * given as 'type', which must be one of IPADDR_TYPE_{V4,ANY,V6}.  If it is
 * IPADDR_TYPE_V4, 'addr' is expected to point to a sockaddr_in structure.  If
 * it is IPADDR_TYPE_{ANY,V6}, 'addr' is expected to point to a sockaddr_in6
 * structure.  For the _ANY case, the result will be an _ANY address only if it
 * is the unspecified (all-zeroes) address and a _V6 address in all other
 * cases.  For the _V6 case, the result will always be a _V6 address.  The
 * length of the structure pointed to by 'addr' is given as 'addr_len'.  If the
 * boolean 'kame' flag is set, addresses will be interpreted to be KAME style,
 * meaning that for scoped IPv6 addresses, the zone is embedded in the address
 * rather than given in sin6_scope_id.  On success, store the resulting IP
 * address in 'ipaddr'.  If 'port' is not NULL, store the port number in it;
 * otherwise, ignore the port number.  On any parsing failure, return an
 * appropriate negative error code.
 */
int
addr_get_inet(const struct sockaddr * addr, socklen_t addr_len, uint8_t type,
        ip_addr_t * ipaddr, int kame, uint16_t * port)
{
        struct sockaddr_in sin;
        struct sockaddr_in6 sin6;
        ip6_addr_t *ip6addr;
        uint32_t ifindex;

        switch (type) {
        case IPADDR_TYPE_V4:
                if (addr_len != sizeof(sin))
                        return EINVAL;

                /*
                 * Getting around strict aliasing problems.  Oh, the irony of
                 * doing an extra memcpy so that the compiler can do a better
                 * job at optimizing..
                 */
                memcpy(&sin, addr, sizeof(sin));

                if (sin.sin_family != AF_INET)
                        return EAFNOSUPPORT;

                ip_addr_set_ip4_u32(ipaddr, sin.sin_addr.s_addr);

                if (port != NULL)
                        *port = ntohs(sin.sin_port);

                return OK;

        case IPADDR_TYPE_ANY:
        case IPADDR_TYPE_V6:
                if (addr_len != sizeof(sin6))
                        return EINVAL;

                /* Again, strict aliasing.. */
                memcpy(&sin6, addr, sizeof(sin6));

                if (sin6.sin6_family != AF_INET6)
                        return EAFNOSUPPORT;

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

                /*
                 * This is a bit ugly, but NetBSD does not expose s6_addr32 and
                 * s6_addr is a series of bytes, which is a mismatch for lwIP.
                 * The alternative would be another memcpy..
                 */
                ip6addr = ip_2_ip6(ipaddr);
                assert(sizeof(ip6addr->addr) == sizeof(sin6.sin6_addr));
                memcpy(ip6addr->addr, &sin6.sin6_addr, sizeof(ip6addr->addr));

                /*
                 * If the address may have a scope, extract the zone ID.
                 * Where the zone ID is depends on the 'kame' parameter: KAME-
                 * style addresses have it embedded within the address, whereas
                 * non-KAME addresses use the (misnamed) sin6_scope_id field.
                 */
                if (ip6_addr_has_scope(ip6addr, IP6_UNKNOWN)) {
                        if (kame) {
                                ifindex =
                                    ntohl(ip6addr->addr[0]) & 0x0000ffffUL;

                                ip6addr->addr[0] &= PP_HTONL(0xffff0000UL);
                        } else {
                                /*
                                 * Reject KAME-style addresses for normal
                                 * socket calls, to save ourselves the trouble
                                 * of mixed address styles elsewhere.
                                 */
                                if (ip6addr->addr[0] & PP_HTONL(0x0000ffffUL))
                                        return EINVAL;

                                ifindex = sin6.sin6_scope_id;
                        }

                        /*
                         * Reject invalid zone IDs.  This also enforces that
                         * no zone IDs wider than eight bits enter the system.
                         * As a side effect, it is not possible to add routes
                         * for invalid zones, but that should be no problem.
                         */
                        if (ifindex != 0 &&
                            ifdev_get_by_index(ifindex) == NULL)
                                return ENXIO;

                        ip6_addr_set_zone(ip6addr, ifindex);
                } else
                        ip6_addr_clear_zone(ip6addr);

                /*
                 * Set the type to ANY if it was ANY and the address itself is
                 * ANY as well.  Otherwise, we are binding to a specific IPv6
                 * address, so IPV6_V6ONLY stops being relevant and we should
                 * leave the address set to V6.  Destination addresses for ANY
                 * are set to V6 elsewhere.
                 */
                if (type == IPADDR_TYPE_ANY && ip6_addr_isany(ip6addr))
                        IP_SET_TYPE(ipaddr, type);
                else
                        IP_SET_TYPE(ipaddr, IPADDR_TYPE_V6);

                if (port != NULL)
                        *port = ntohs(sin6.sin6_port);

                return OK;

        default:
                return EAFNOSUPPORT;
        }
}

/*
 * Store an lwIP-style IP address and port number as a sockaddr structure
 * (sockaddr_in or sockaddr_in6, depending on the given IP address) to be
 * copied to userland.  The result is stored in the buffer pointed to by
 * 'addr'.  Before the call, 'addr_len' must be set to the size of this buffer.
 * This is an internal check to prevent buffer overflows, and must not be used
 * to validate input, since a mismatch will trigger a panic.  After the call,
 * 'addr_len' will be set to the size of the resulting structure.  The lwIP-
 * style address is given as 'ipaddr'.  If the boolean 'kame' flag is set, the
 * address will be stored KAME-style, meaning that for scoped IPv6 addresses,
 * the address zone will be stored embedded in the address rather than in
 * sin6_scope_id.  If relevant, 'port' contains the port number in host-byte
 * order; otherwise it should be set to zone.
 */
void
addr_put_inet(struct sockaddr * addr, socklen_t * addr_len,
        const ip_addr_t * ipaddr, int kame, uint16_t port)
{
        struct sockaddr_in sin;
        struct sockaddr_in6 sin6;
        const ip6_addr_t *ip6addr;
        uint32_t zone;

        switch (IP_GET_TYPE(ipaddr)) {
        case IPADDR_TYPE_V4:
                if (*addr_len < sizeof(sin))
                        panic("provided address buffer too small");

                memset(&sin, 0, sizeof(sin));

                sin.sin_len = sizeof(sin);
                sin.sin_family = AF_INET;
                sin.sin_port = htons(port);
                sin.sin_addr.s_addr = ip_addr_get_ip4_u32(ipaddr);

                memcpy(addr, &sin, sizeof(sin));
                *addr_len = sizeof(sin);

                break;

        case IPADDR_TYPE_ANY:
        case IPADDR_TYPE_V6:
                if (*addr_len < sizeof(sin6))
                        panic("provided address buffer too small");

                ip6addr = ip_2_ip6(ipaddr);

                memset(&sin6, 0, sizeof(sin6));

                sin6.sin6_len = sizeof(sin6);
                sin6.sin6_family = AF_INET6;
                sin6.sin6_port = htons(port);
                memcpy(&sin6.sin6_addr, ip6addr->addr, sizeof(sin6.sin6_addr));

                /*
                 * If the IPv6 address has a zone set, it must be scoped, and
                 * we put the zone in the result.  It may occur that a scoped
                 * IPv6 address does not have a zone here though, for example
                 * if packet routing fails for sendto() with a zoneless address
                 * on an unbound socket, resulting in an RTM_MISS message.  In
                 * such cases, simply leave the zone index blank in the result.
                 */
                if (ip6_addr_has_zone(ip6addr)) {
                        assert(ip6_addr_has_scope(ip6addr, IP6_UNKNOWN));

                        zone = ip6_addr_zone(ip6addr);
                        assert(zone <= UINT8_MAX);

                        if (kame)
                                sin6.sin6_addr.s6_addr[3] = zone;
                        else
                                sin6.sin6_scope_id = zone;
                }

                memcpy(addr, &sin6, sizeof(sin6));
                *addr_len = sizeof(sin6);

                break;

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

/*
 * Load a link-layer sockaddr structure (sockaddr_dl), as copied from userland,
 * and return the contained name and/or hardware address.  The address is
 * provided as 'addr', with length 'addr_len'.  On success, return OK.  If
 * 'name' is not NULL, it must be of size 'name_max', and will be used to store
 * the (null-terminated) interface name in the given structure if present, or
 * the empty string if not.  If 'hwaddr' is not NULL, it will be used to store
 * the hardware address in the given structure, which must in that case be
 * present and exactly 'hwaddr_len' bytes long.  On any parsing failure, return
 * an appropriate negative error code.
 */
int
addr_get_link(const struct sockaddr * addr, socklen_t addr_len, char * name,
        size_t name_max, uint8_t * hwaddr, size_t hwaddr_len)
{
        struct sockaddr_dlx sdlx;
        size_t nlen, alen;

        if (addr_len < offsetof(struct sockaddr_dlx, sdlx_data))
                return EINVAL;

        /*
         * We cannot prevent callers from passing in massively oversized
         * sockaddr_dl structure.  However, we insist that all the actual data
         * be contained within the size of our sockaddr_dlx version.
         */
        if (addr_len > sizeof(sdlx))
                addr_len = sizeof(sdlx);

        memcpy(&sdlx, addr, addr_len);

        if (sdlx.sdlx_family != AF_LINK)
                return EAFNOSUPPORT;

        /* Address selectors are not currently supported. */
        if (sdlx.sdlx_slen != 0)
                return EINVAL;

        nlen = (size_t)sdlx.sdlx_nlen;
        alen = (size_t)sdlx.sdlx_alen;

        /* The nlen and alen fields are 8-bit, so no risks of overflow here. */
        if (addr_len < offsetof(struct sockaddr_dlx, sdlx_data) + nlen + alen)
                return EINVAL;

        /*
         * Copy out the name, truncating it if needed.  The name in the
         * sockaddr is not null terminated, so we have to do that.  If the
         * sockaddr has no name, copy out an empty name.
         */
        if (name != NULL) {
                assert(name_max > 0);

                if (name_max > nlen + 1)
                        name_max = nlen + 1;

                memcpy(name, sdlx.sdlx_data, name_max - 1);
                name[name_max - 1] = '\0';
        }

        /*
         * Copy over the hardware address.  For simplicity, we require that the
         * caller specify the exact hardware address length.
         */
        if (hwaddr != NULL) {
                if (alen != hwaddr_len)
                        return EINVAL;

                memcpy(hwaddr, sdlx.sdlx_data + nlen, hwaddr_len);
        }

        return OK;
}

/*
 * Store a link-layer sockaddr structure (sockaddr_dl), to be copied to
 * userland.  The result is stored in the buffer pointed to by 'addr'.  Before
 * the call, 'addr_len' must be set to the size of this buffer.  This is an
 * internal check to prevent buffer overflows, and must not be used to validate
 * input, since a mismatch will trigger a panic.  After the call, 'addr_len'
 * will be set to the size of the resulting structure.  The given interface
 * index 'ifindex' and (IFT_) interface type 'type' will always be stored in
 * the resulting structure.  If 'name' is not NULL, it must be a null-
 * terminated interface name string which will be included in the structure.
 * If 'hwaddr' is not NULL, it must be a hardware address of length
 * 'hwaddr_len', which will also be included in the structure.
 */
void
addr_put_link(struct sockaddr * addr, socklen_t * addr_len, uint32_t ifindex,
        uint32_t type, const char * name, const uint8_t * hwaddr,
        size_t hwaddr_len)
{
        struct sockaddr_dlx sdlx;
        size_t name_len;
        socklen_t len;

        name_len = (name != NULL) ? strlen(name) : 0;

        if (hwaddr == NULL)
                hwaddr_len = 0;

        assert(name_len < IFNAMSIZ);
        assert(hwaddr_len <= NETIF_MAX_HWADDR_LEN);

        len = offsetof(struct sockaddr_dlx, sdlx_data) + name_len + hwaddr_len;

        if (*addr_len < len)
                panic("provided address buffer too small");

        memset(&sdlx, 0, sizeof(sdlx));
        sdlx.sdlx_len = len;
        sdlx.sdlx_family = AF_LINK;
        sdlx.sdlx_index = ifindex;
        sdlx.sdlx_type = type;
        sdlx.sdlx_nlen = name_len;
        sdlx.sdlx_alen = hwaddr_len;
        if (name_len > 0)
                memcpy(sdlx.sdlx_data, name, name_len);
        if (hwaddr_len > 0)
                memcpy(sdlx.sdlx_data + name_len, hwaddr, hwaddr_len);

        memcpy(addr, &sdlx, len);
        *addr_len = len;
}

/*
 * Convert an IPv4 or IPv6 netmask, given as sockaddr structure 'addr', to a
 * prefix length.  The length of the sockaddr structure is given as 'addr_len'.
 * For consistency with addr_get_inet(), the expected address type is given as
 * 'type', and must be either IPADDR_TYPE_V4 or IPADDR_TYPE_V6.  On success,
 * return OK with the number of set prefix bits returned in 'prefix', and
 * optionally with a lwIP representation of the netmask stored in 'ipaddr' (if
 * not NULL).  On failure, return an appropriate negative error code.  Note
 * that this function does not support compressed IPv4 network masks; such
 * addresses must be expanded before a call to this function.
 */
int
addr_get_netmask(const struct sockaddr * addr, socklen_t addr_len,
        uint8_t type, unsigned int * prefix, ip_addr_t * ipaddr)
{
        struct sockaddr_in sin;
        struct sockaddr_in6 sin6;
        unsigned int byte, bit;
        uint32_t val;

        switch (type) {
        case IPADDR_TYPE_V4:
                if (addr_len != sizeof(sin))
                        return EINVAL;

                memcpy(&sin, addr, sizeof(sin));

                if (sin.sin_family != AF_INET)
                        return EAFNOSUPPORT;

                val = ntohl(sin.sin_addr.s_addr);

                /* Find the first zero bit. */
                for (bit = 0; bit < IP4_BITS; bit++)
                        if (!(val & (1 << (IP4_BITS - bit - 1))))
                                break;

                *prefix = bit;

                /* All bits after the first zero bit must also be zero. */
                if (bit < IP4_BITS &&
                    (val & ((1 << (IP4_BITS - bit - 1)) - 1)))
                        return EINVAL;

                if (ipaddr != NULL)
                        ip_addr_set_ip4_u32(ipaddr, sin.sin_addr.s_addr);

                return OK;

        case IPADDR_TYPE_V6:
                if (addr_len != sizeof(sin6))
                        return EINVAL;

                memcpy(&sin6, addr, sizeof(sin6));

                if (sin6.sin6_family != AF_INET6)
                        return EAFNOSUPPORT;

                /* Find the first zero bit. */
                for (byte = 0; byte < __arraycount(sin6.sin6_addr.s6_addr);
                    byte++)
                        if (sin6.sin6_addr.s6_addr[byte] != 0xff)
                                break;

                /* If all bits are set, there is nothing more to do. */
                if (byte == __arraycount(sin6.sin6_addr.s6_addr)) {
                        *prefix = __arraycount(sin6.sin6_addr.s6_addr) * NBBY;

                        return OK;
                }

                for (bit = 0; bit < NBBY; bit++)
                        if (!(sin6.sin6_addr.s6_addr[byte] &
                            (1 << (NBBY - bit - 1))))
                                break;

                *prefix = byte * NBBY + bit;

                /* All bits after the first zero bit must also be zero. */
                if (bit < NBBY && (sin6.sin6_addr.s6_addr[byte] &
                    ((1 << (NBBY - bit - 1)) - 1)))
                        return EINVAL;

                for (byte++; byte < __arraycount(sin6.sin6_addr.s6_addr);
                    byte++)
                        if (sin6.sin6_addr.s6_addr[byte] != 0)
                                return EINVAL;

                if (ipaddr != NULL) {
                        ip_addr_set_zero_ip6(ipaddr);

                        memcpy(ip_2_ip6(ipaddr)->addr, &sin6.sin6_addr,
                            sizeof(ip_2_ip6(ipaddr)->addr));
                }

                return OK;

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

/*
 * Generate a raw network mask based on the given prefix length.
 */
void
addr_make_netmask(uint8_t * addr, socklen_t addr_len, unsigned int prefix)
{
        unsigned int byte, bit;

        byte = prefix / NBBY;
        bit = prefix % NBBY;

        assert(byte + !!bit <= addr_len);

        if (byte > 0)
                memset(addr, 0xff, byte);
        if (bit != 0)
                addr[byte++] = (uint8_t)(0xff << (NBBY - bit));
        if (byte < addr_len)
                memset(&addr[byte], 0, addr_len - byte);
}

/*
 * Store a network mask as a sockaddr structure, in 'addr'.  Before the call,
 * 'addr_len' must be set to the memory size of 'addr'.  The address type is
 * given as 'type', and must be either IPADDR_TYPE_V4 or IPADDR_TYPE_V6.  The
 * prefix length from which to generate the network mask is given as 'prefix'.
 * Upon return, 'addr_len' is set to the size of the resulting sockaddr
 * structure.
 */
void
addr_put_netmask(struct sockaddr * addr, socklen_t * addr_len, uint8_t type,
        unsigned int prefix)
{
        struct sockaddr_in sin;
        struct sockaddr_in6 sin6;

        switch (type) {
        case IPADDR_TYPE_V4:
                if (*addr_len < sizeof(sin))
                        panic("provided address buffer too small");

                assert(prefix <= IP4_BITS);

                memset(&sin, 0, sizeof(sin));
                sin.sin_len = sizeof(sin);
                sin.sin_family = AF_INET;

                addr_make_netmask((uint8_t *)&sin.sin_addr.s_addr,
                    sizeof(sin.sin_addr.s_addr), prefix);

                memcpy(addr, &sin, sizeof(sin));
                *addr_len = sizeof(sin);

                break;

        case IPADDR_TYPE_V6:
                if (*addr_len < sizeof(sin6))
                        panic("provided address buffer too small");

                assert(prefix <= IP6_BITS);

                memset(&sin6, 0, sizeof(sin6));
                sin6.sin6_len = sizeof(sin6);
                sin6.sin6_family = AF_INET6;

                addr_make_netmask(sin6.sin6_addr.s6_addr,
                    sizeof(sin6.sin6_addr.s6_addr), prefix);

                memcpy(addr, &sin6, sizeof(sin6));
                *addr_len = sizeof(sin6);

                break;

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

/*
 * Normalize the given address in 'src' to the given number of prefix bits,
 * setting all other bits to zero.  Return the result in 'dst'.
 */
void
addr_normalize(ip_addr_t * dst, const ip_addr_t * src, unsigned int prefix)
{
#if !defined(NDEBUG)
        unsigned int addr_len;
#endif /* !defined(NDEBUG) */
        unsigned int byte, bit;
        const uint8_t *srcaddr;
        uint8_t type, *dstaddr;

        type = IP_GET_TYPE(src);

        memset(dst, 0, sizeof(*dst));
        IP_SET_TYPE(dst, type);

        switch (type) {
        case IPADDR_TYPE_V4:
                srcaddr = (const uint8_t *)&ip_2_ip4(src)->addr;
                dstaddr = (uint8_t *)&ip_2_ip4(dst)->addr;
#if !defined(NDEBUG)
                addr_len = sizeof(ip_2_ip4(src)->addr);
#endif /* !defined(NDEBUG) */

                break;

        case IPADDR_TYPE_V6:
                ip6_addr_set_zone(ip_2_ip6(dst), ip6_addr_zone(ip_2_ip6(src)));

                srcaddr = (const uint8_t *)&ip_2_ip6(src)->addr;
                dstaddr = (uint8_t *)&ip_2_ip6(dst)->addr;
#if !defined(NDEBUG)
                addr_len = sizeof(ip_2_ip6(src)->addr);
#endif /* !defined(NDEBUG) */

                break;

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

        byte = prefix / NBBY;
        bit = prefix % NBBY;

        assert(byte + !!bit <= addr_len);

        if (byte > 0)
                memcpy(dstaddr, srcaddr, byte);
        if (bit != 0) {
                dstaddr[byte] =
                    srcaddr[byte] & (uint8_t)(0xff << (NBBY - bit));
                byte++;
        }
}

/*
 * Return the number of common bits between the given two addresses, up to the
 * given maximum.  Thus, return a value between 0 and 'max' inclusive.
 */
unsigned int
addr_get_common_bits(const ip_addr_t * ipaddr1, const ip_addr_t * ipaddr2,
        unsigned int max)
{
        unsigned int addr_len, prefix, bit;
        const uint8_t *addr1, *addr2;
        uint8_t byte;

        switch (IP_GET_TYPE(ipaddr1)) {
        case IPADDR_TYPE_V4:
                assert(IP_IS_V4(ipaddr2));

                addr1 = (const uint8_t *)&ip_2_ip4(ipaddr1)->addr;
                addr2 = (const uint8_t *)&ip_2_ip4(ipaddr2)->addr;
                addr_len = sizeof(ip_2_ip4(ipaddr1)->addr);

                break;

        case IPADDR_TYPE_V6:
                assert(IP_IS_V6(ipaddr2));

                addr1 = (const uint8_t *)&ip_2_ip6(ipaddr1)->addr;
                addr2 = (const uint8_t *)&ip_2_ip6(ipaddr2)->addr;
                addr_len = sizeof(ip_2_ip6(ipaddr1)->addr);

                break;

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

        if (addr_len > max * NBBY)
                addr_len = max * NBBY;

        prefix = 0;

        for (prefix = 0; addr_len > 0; addr1++, addr2++, prefix += NBBY) {
                if ((byte = (*addr1 ^ *addr2)) != 0) {
                        /* TODO: see if we want a lookup table for this. */
                        for (bit = 0; bit < NBBY; bit++, prefix++)
                                if (byte & (1 << (NBBY - bit - 1)))
                                        break;
                        break;
                }
        }

        if (prefix > max)
                prefix = max;

        return prefix;
}

/*
 * Convert the given IPv4 address to an IPv4-mapped IPv6 address.
 */
void
addr_make_v4mapped_v6(ip_addr_t * dst, const ip4_addr_t * src)
{

        IP_ADDR6(dst, 0, 0, PP_HTONL(0x0000ffffUL), ip4_addr_get_u32(src));
}