Remove building with NOCRYPTO option

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

/* LWIP service - ipsock.c - shared IP-level socket code */

#include "lwip.h"
#include "ifaddr.h"

#define ip6_hdr __netbsd_ip6_hdr        /* conflicting definitions */
#include <net/route.h>
#include <netinet/ip.h>
#include <netinet/in_pcb.h>
#include <netinet6/in6_pcb.h>
#undef ip6_hdr

/* The following are sysctl(7) settings. */
int lwip_ip4_forward = 0;               /* We patch lwIP to check these.. */
int lwip_ip6_forward = 0;               /*  ..two settings at run time.   */
static int ipsock_v6only = 1;

/* The CTL_NET PF_INET IPPROTO_IP subtree. */
static struct rmib_node net_inet_ip_table[] = {
/* 1*/  [IPCTL_FORWARDING]      = RMIB_INTPTR(RMIB_RW, &lwip_ip4_forward,
                                    "forwarding",
                                    "Enable forwarding of INET diagrams"),
/* 3*/  [IPCTL_DEFTTL]          = RMIB_INT(RMIB_RO, IP_DEFAULT_TTL, "ttl",
                                    "Default TTL for an INET diagram"),
/*23*/  [IPCTL_LOOPBACKCKSUM]   = RMIB_FUNC(RMIB_RW | CTLTYPE_INT, sizeof(int),
                                    loopif_cksum, "do_loopback_cksum",
                                    "Perform IP checksum on loopback"),
};

static struct rmib_node net_inet_ip_node =
    RMIB_NODE(RMIB_RO, net_inet_ip_table, "ip", "IPv4 related settings");

/* The CTL_NET PF_INET6 IPPROTO_IPV6 subtree. */
static struct rmib_node net_inet6_ip6_table[] = {
/* 1*/  [IPV6CTL_FORWARDING]    = RMIB_INTPTR(RMIB_RW, &lwip_ip6_forward,
                                    "forwarding",
                                    "Enable forwarding of INET6 diagrams"),
                                /*
                                 * The following functionality is not
                                 * implemented in lwIP at this time.
                                 */
/* 2*/  [IPV6CTL_SENDREDIRECTS] = RMIB_INT(RMIB_RO, 0, "redirect", "Enable "
                                    "sending of ICMPv6 redirect messages"),
/* 3*/  [IPV6CTL_DEFHLIM]       = RMIB_INT(RMIB_RO, IP_DEFAULT_TTL, "hlim",
                                    "Hop limit for an INET6 datagram"),
/*12*/  [IPV6CTL_ACCEPT_RTADV]  = RMIB_INTPTR(RMIB_RW, &ifaddr_accept_rtadv,
                                    "accept_rtadv",
                                    "Accept router advertisements"),
/*16*/  [IPV6CTL_DAD_COUNT]     = RMIB_INT(RMIB_RO,
                                    LWIP_IPV6_DUP_DETECT_ATTEMPTS, "dad_count",
                                    "Number of Duplicate Address Detection "
                                    "probes to send"),
/*24*/  [IPV6CTL_V6ONLY]        = RMIB_INTPTR(RMIB_RW, &ipsock_v6only,
                                    "v6only", "Disallow PF_INET6 sockets from "
                                    "connecting to PF_INET sockets"),
                                /*
                                 * The following setting is significantly
                                 * different from NetBSD, and therefore it has
                                 * a somewhat different description as well.
                                 */
/*35*/  [IPV6CTL_AUTO_LINKLOCAL]= RMIB_INTPTR(RMIB_RW, &ifaddr_auto_linklocal,
                                    "auto_linklocal", "Enable global support "
                                    "for adding IPv6link-local addresses to "
                                    "interfaces"),
                                /*
                                 * Temporary addresses are managed entirely by
                                 * userland.  We only maintain the settings.
                                 */
/*+0*/  [IPV6CTL_MAXID]         = RMIB_INT(RMIB_RW, 0, "use_tempaddr",
                                    "Use temporary address"),
/*+1*/  [IPV6CTL_MAXID + 1]     = RMIB_INT(RMIB_RW, 86400, "temppltime",
                                    "Preferred lifetime of a temporary "
                                    "address"),
/*+2*/  [IPV6CTL_MAXID + 2]     = RMIB_INT(RMIB_RW, 604800, "tempvltime",
                                    "Valid lifetime of a temporary address"),
};

static struct rmib_node net_inet6_ip6_node =
    RMIB_NODE(RMIB_RO, net_inet6_ip6_table, "ip6", "IPv6 related settings");

/*
 * Initialize the IP sockets module.
 */
void
ipsock_init(void)
{

        /*
         * Register the net.inet.ip and net.inet6.ip6 subtrees.  Unlike for the
         * specific protocols (TCP/UDP/RAW), here the IPv4 and IPv6 subtrees
         * are and must be separate, even though many settings are shared
         * between the two at the lwIP level.  Ultimately we may have to split
         * the subtrees for the specific protocols, too, though..
         */
        mibtree_register_inet(AF_INET, IPPROTO_IP, &net_inet_ip_node);
        mibtree_register_inet(AF_INET6, IPPROTO_IPV6, &net_inet6_ip6_node);
}

/*
 * Return the lwIP IP address type (IPADDR_TYPE_) for the given IP socket.
 */
static int
ipsock_get_type(struct ipsock * ip)
{

        if (!(ip->ip_flags & IPF_IPV6))
                return IPADDR_TYPE_V4;
        else if (ip->ip_flags & IPF_V6ONLY)
                return IPADDR_TYPE_V6;
        else
                return IPADDR_TYPE_ANY;
}

/*
 * Create an IP socket, for the given (PF_/AF_) domain and initial send and
 * receive buffer sizes.  Return the lwIP IP address type that should be used
 * to create the corresponding PCB.  Return a pointer to the libsockevent
 * socket in 'sockp'.  This function must not allocate any resources in any
 * form, as socket creation may still fail later, in which case no destruction
 * function is called.
 */
int
ipsock_socket(struct ipsock * ip, int domain, size_t sndbuf, size_t rcvbuf,
        struct sock ** sockp)
{

        ip->ip_flags = (domain == AF_INET6) ? IPF_IPV6 : 0;

        if (domain == AF_INET6 && ipsock_v6only)
                ip->ip_flags |= IPF_V6ONLY;

        ip->ip_sndbuf = sndbuf;
        ip->ip_rcvbuf = rcvbuf;

        /* Important: when adding settings here, also change ipsock_clone(). */

        *sockp = &ip->ip_sock;

        return ipsock_get_type(ip);
}

/*
 * Clone the given socket 'ip' into the new socket 'newip', using the socket
 * identifier 'newid'.  In particular, tell libsockevent about the clone and
 * copy over any settings from 'ip' to 'newip' that can be inherited on a
 * socket.  Cloning is used for new TCP connections arriving on listening TCP
 * sockets.  This function must not fail.
 */
void
ipsock_clone(struct ipsock * ip, struct ipsock * newip, sockid_t newid)
{

        sockevent_clone(&ip->ip_sock, &newip->ip_sock, newid);

        /* Inherit all settings from the original socket. */
        newip->ip_flags = ip->ip_flags;
        newip->ip_sndbuf = ip->ip_sndbuf;
        newip->ip_rcvbuf = ip->ip_rcvbuf;
}

/*
 * Create an <any> address for the given socket, taking into account whether
 * the socket is IPv4, IPv6, or mixed.  The generated address, stored in
 * 'ipaddr', will have the same type as returned from the ipsock_socket() call.
 */
void
ipsock_get_any_addr(struct ipsock * ip, ip_addr_t * ipaddr)
{

        ip_addr_set_any(ipsock_is_ipv6(ip), ipaddr);

        if (ipsock_is_ipv6(ip) && !ipsock_is_v6only(ip))
                IP_SET_TYPE(ipaddr, IPADDR_TYPE_ANY);
}

/*
 * Verify whether the given (properly scoped) IP address is a valid source
 * address for the given IP socket.  The 'allow_mcast' flag indicates whether
 * the source address is allowed to be a multicast address.  Return OK on
 * success.  If 'ifdevp' is not NULL, it is filled with either the interface
 * that owns the address, or NULL if the address is (while valid) not
 * associated with a particular interface.  On failure, return a negative error
 * code.  This function must be called, in one way or another, for every source
 * address used for binding or sending on a IP-layer socket.
 */
int
ipsock_check_src_addr(struct ipsock * ip, ip_addr_t * ipaddr, int allow_mcast,
        struct ifdev ** ifdevp)
{
        ip6_addr_t *ip6addr;
        struct ifdev *ifdev;
        uint32_t inaddr, zone;
        int is_mcast;

        /*
         * TODO: for now, forbid binding to multicast addresses.  Callers that
         * never allow multicast addresses anyway (e.g., IPV6_PKTINFO) should
         * do their own check for this; the one here may eventually be removed.
         */
        is_mcast = ip_addr_ismulticast(ipaddr);

        if (is_mcast && !allow_mcast)
                return EADDRNOTAVAIL;

        if (IP_IS_V6(ipaddr)) {
                /*
                 * The given address must not have a KAME-style embedded zone.
                 * This check is already performed in addr_get_inet(), but we
                 * have to replicate it here because not all source addresses
                 * go through addr_get_inet().
                 */
                ip6addr = ip_2_ip6(ipaddr);

                if (ip6_addr_has_scope(ip6addr, IP6_UNKNOWN) &&
                    (ip6addr->addr[0] & PP_HTONL(0x0000ffffUL)))
                        return EINVAL;

                /*
                 * lwIP does not support IPv4-mapped IPv6 addresses, so these
                 * must be converted to plain IPv4 addresses instead.  The IPv4
                 * 'any' address is not supported in this form.  In V6ONLY
                 * mode, refuse connecting or sending to IPv4-mapped addresses
                 * at all.
                 */
                if (ip6_addr_isipv4mappedipv6(ip6addr)) {
                        if (ipsock_is_v6only(ip))
                                return EINVAL;

                        inaddr = ip6addr->addr[3];

                        if (inaddr == PP_HTONL(INADDR_ANY))
                                return EADDRNOTAVAIL;

                        ip_addr_set_ip4_u32(ipaddr, inaddr);
                }
        }

        ifdev = NULL;

        if (!ip_addr_isany(ipaddr)) {
                if (IP_IS_V6(ipaddr) &&
                    ip6_addr_lacks_zone(ip_2_ip6(ipaddr), IP6_UNKNOWN))
                        return EADDRNOTAVAIL;

                /*
                 * If the address is a unicast address, it must be assigned to
                 * an interface.  Otherwise, if it is a zoned multicast
                 * address, the zone denotes the interface.  For global
                 * multicast addresses, we cannot determine an interface.
                 */
                if (!is_mcast) {
                        if ((ifdev = ifaddr_map_by_addr(ipaddr)) == NULL)
                                return EADDRNOTAVAIL;
                } else {
                        /* Some multicast addresses are not acceptable. */
                        if (!addr_is_valid_multicast(ipaddr))
                                return EINVAL;

                        if (IP_IS_V6(ipaddr) &&
                            ip6_addr_has_zone(ip_2_ip6(ipaddr))) {
                                zone = ip6_addr_zone(ip_2_ip6(ipaddr));

                                if ((ifdev = ifdev_get_by_index(zone)) == NULL)
                                        return ENXIO;
                        }
                }
        }

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

        return OK;
}

/*
 * Retrieve and validate a source address for use in a socket bind call on
 * socket 'ip'.  The user-provided address is given as 'addr', with length
 * 'addr_len'.  The socket's current local IP address and port are given as
 * 'local_ip' and 'local_port', respectively; for raw sockets, the given local
 * port number is always zero.  The caller's endpoint is given as 'user_endpt',
 * used to make sure only root can bind to local port numbers.  The boolean
 * 'allow_mcast' flag indicates whether the source address is allowed to be a
 * multicast address.  On success, return OK with the source IP address stored
 * in 'src_addr' and, if 'src_port' is not NULL, the port number to bind to
 * stored in 'portp'.  Otherwise, return a negative error code.  This function
 * performs all the tasks necessary before the socket can be bound using a lwIP
 * call.
 */
int
ipsock_get_src_addr(struct ipsock * ip, const struct sockaddr * addr,
        socklen_t addr_len, endpoint_t user_endpt, ip_addr_t * local_ip,
        uint16_t local_port, int allow_mcast, ip_addr_t * src_addr,
        uint16_t * src_port)
{
        uint16_t port;
        int r;

        /*
         * If the socket has been bound already, it cannot be bound again.
         * We check this by checking whether the current local port is non-
         * zero.  This rule does not apply to raw sockets, but raw sockets have
         * no port numbers anyway, so this conveniently works out.  However,
         * raw sockets may not be rebound after being connected, but that is
         * checked before we even get here.
         */
        if (local_port != 0)
                return EINVAL;

        /* Parse the user-provided address. */
        if ((r = addr_get_inet(addr, addr_len, ipsock_get_type(ip), src_addr,
            FALSE /*kame*/, &port)) != OK)
                return r;

        /* Validate the user-provided address. */
        if ((r = ipsock_check_src_addr(ip, src_addr, allow_mcast,
            NULL /*ifdevp*/)) != OK)
                return r;

        /*
         * If we are interested in port numbers at all (for non-raw sockets,
         * meaning portp is not NULL), make sure that only the superuser can
         * bind to privileged port numbers.  For raw sockets, only the
         * superuser can open a socket anyway, so we need no check here.
         */
        if (src_port != NULL) {
                if (port != 0 && port < IPPORT_RESERVED &&
                    !util_is_root(user_endpt))
                        return EACCES;

                *src_port = port;
        }

        return OK;
}

/*
 * Retrieve and validate a destination address for use in a socket connect or
 * sendto call.  The user-provided address is given as 'addr', with length
 * 'addr_len'.  The socket's current local IP address is given as 'local_addr'.
 * On success, return OK with the destination IP address stored in 'dst_addr'
 * and, if 'dst_port' is not NULL, the port number to bind to stored in
 * 'dst_port'.  Otherwise, return a negative error code.  This function must be
 * called, in one way or another, for every destination address used for
 * connecting or sending on a IP-layer socket.
 */
int
ipsock_get_dst_addr(struct ipsock * ip, const struct sockaddr * addr,
        socklen_t addr_len, const ip_addr_t * local_addr, ip_addr_t * dst_addr,
        uint16_t * dst_port)
{
        uint16_t port;
        int r;

        /* Parse the user-provided address. */
        if ((r = addr_get_inet(addr, addr_len, ipsock_get_type(ip), dst_addr,
            FALSE /*kame*/, &port)) != OK)
                return r;

        /* Destination addresses are always specific. */
        if (IP_GET_TYPE(dst_addr) == IPADDR_TYPE_ANY)
                IP_SET_TYPE(dst_addr, IPADDR_TYPE_V6);

        /*
         * lwIP does not support IPv4-mapped IPv6 addresses, so these must be
         * supported to plain IPv4 addresses instead.  In V6ONLY mode, refuse
         * connecting or sending to IPv4-mapped addresses at all.
         */
        if (IP_IS_V6(dst_addr) &&
            ip6_addr_isipv4mappedipv6(ip_2_ip6(dst_addr))) {
                if (ipsock_is_v6only(ip))
                        return EINVAL;

                ip_addr_set_ip4_u32(dst_addr, ip_2_ip6(dst_addr)->addr[3]);
        }

        /*
         * Now make sure that the local and remote addresses are of the same
         * family.  The local address may be of type IPADDR_TYPE_ANY, which is
         * allowed for both IPv4 and IPv6.  Even for connectionless socket
         * types we must perform this check as part of connect calls (as well
         * as sendto calls!) because otherwise we will create problems for
         * sysctl based socket enumeration (i.e., netstat), which uses the
         * local IP address type to determine the socket family.
         */
        if (IP_GET_TYPE(local_addr) != IPADDR_TYPE_ANY &&
            IP_IS_V6(local_addr) != IP_IS_V6(dst_addr))
                return EINVAL;

        /*
         * TODO: on NetBSD, an 'any' destination address is replaced with a
         * local interface address.
         */
        if (ip_addr_isany(dst_addr))
                return EHOSTUNREACH;

        /*
         * If the address is a multicast address, the multicast address itself
         * must be valid.
         */
        if (ip_addr_ismulticast(dst_addr) &&
            !addr_is_valid_multicast(dst_addr))
                return EINVAL;

        /*
         * TODO: decide whether to add a zone to a scoped IPv6 address that
         * lacks a zone.  For now, we let lwIP handle this, as lwIP itself
         * will always add the zone at some point.  If anything changes there,
         * this would be the place to set the zone (using a route lookup).
         */

        /*
         * For now, we do not forbid or alter any other particular destination
         * addresses.
         */

        if (dst_port != NULL) {
                /*
                 * Disallow connecting/sending to port zero.  There is no error
                 * code that applies well to this case, so we copy NetBSD's.
                 */
                if (port == 0)
                        return EADDRNOTAVAIL;

                *dst_port = port;
        }

        return OK;
}

/*
 * Store the address 'ipaddr' associated with the socket 'ip' (for example, it
 * may be the local or remote IP address of the socket) as a sockaddr structure
 * in 'addr'.  A port number is provided as 'port' (in host-byte order) if
 * relevant, and zero is passed in otherwise.  This function MUST only be
 * called from contexts where 'addr' is a buffer provided by libsockevent or
 * libsockdriver, meaning that it is of size SOCKADDR_MAX.  The value pointed
 * to by 'addr_len' is not expected to be initialized in calls to this function
 * (and will typically zero).  On return, 'addr_len' is filled with the length
 * of the address generated in 'addr'.  This function never fails.
 */
void
ipsock_put_addr(struct ipsock * ip, struct sockaddr * addr,
        socklen_t * addr_len, ip_addr_t * ipaddr, uint16_t port)
{
        ip_addr_t mappedaddr;

        /*
         * If the socket is an AF_INET6-type socket, and the given address is
         * an IPv4-type address, store it as an IPv4-mapped IPv6 address.
         */
        if (ipsock_is_ipv6(ip) && IP_IS_V4(ipaddr)) {
                addr_make_v4mapped_v6(&mappedaddr, ip_2_ip4(ipaddr));

                ipaddr = &mappedaddr;
        }

        /*
         * We have good reasons to keep the sockdriver and sockevent APIs as
         * they are, namely, defaulting 'addr_len' to zero such that the caller
         * must provide a non-zero length (only) when returning a valid
         * address.  The consequence here is that we have to know the size of
         * the provided buffer.  For libsockevent callbacks, we are always
         * guaranteed to get a buffer of at least this size.
         */
        *addr_len = SOCKADDR_MAX;

        addr_put_inet(addr, addr_len, ipaddr, FALSE /*kame*/, port);
}

/*
 * Set socket options on an IP socket.
 */
int
ipsock_setsockopt(struct ipsock * ip, int level, int name,
        const struct sockdriver_data * data, socklen_t len,
        struct ipopts * ipopts)
{
        int r, val, allow;
        uint8_t type;

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

                        if (val <= 0 || (size_t)val < ipopts->sndmin ||
                            (size_t)val > ipopts->sndmax)
                                return EINVAL;

                        ip->ip_sndbuf = val;

                        return OK;

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

                        if (val <= 0 || (size_t)val < ipopts->rcvmin ||
                            (size_t)val > ipopts->rcvmax)
                                return EINVAL;

                        ip->ip_rcvbuf = val;

                        return OK;
                }

                break;

        case IPPROTO_IP:
                if (ipsock_is_ipv6(ip))
                        break;

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

                        if (val < 0 || val > UINT8_MAX)
                                return EINVAL;

                        *ipopts->tos = (uint8_t)val;

                        return OK;

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

                        if (val < 0 || val > UINT8_MAX)
                                return EINVAL;

                        *ipopts->ttl = (uint8_t)val;

                        return OK;
                }

                break;

        case IPPROTO_IPV6:
                if (!ipsock_is_ipv6(ip))
                        break;

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

                        if (val < -1 || val > UINT8_MAX)
                                return EINVAL;

                        if (val == -1)
                                val = IP_DEFAULT_TTL;

                        *ipopts->ttl = val;

                        return OK;

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

                        if (val < -1 || val > UINT8_MAX)
                                return EINVAL;

                        if (val == -1)
                                val = 0;

                        *ipopts->tos = val;

                        return OK;

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

                        /*
                         * If the socket has been bound to an actual address,
                         * we still allow the option to be changed, but it no
                         * longer has any effect.
                         */
                        type = IP_GET_TYPE(ipopts->local_ip);
                        allow = (type == IPADDR_TYPE_ANY ||
                            (type == IPADDR_TYPE_V6 &&
                            ip_addr_isany(ipopts->local_ip)));

                        if (val) {
                                ip->ip_flags |= IPF_V6ONLY;

                                type = IPADDR_TYPE_V6;
                        } else {
                                ip->ip_flags &= ~IPF_V6ONLY;

                                type = IPADDR_TYPE_ANY;
                        }

                        if (allow)
                                IP_SET_TYPE(ipopts->local_ip, type);

                        return OK;
                }

                break;
        }

        return ENOPROTOOPT;
}

/*
 * Retrieve socket options on an IP socket.
 */
int
ipsock_getsockopt(struct ipsock * ip, int level, int name,
        const struct sockdriver_data * data, socklen_t * len,
        struct ipopts * ipopts)
{
        int val;

        switch (level) {
        case SOL_SOCKET:
                switch (name) {
                case SO_SNDBUF:
                        val = ip->ip_sndbuf;

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

                case SO_RCVBUF:
                        val = ip->ip_rcvbuf;

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

                break;

        case IPPROTO_IP:
                if (ipsock_is_ipv6(ip))
                        break;

                switch (name) {
                case IP_TOS:
                        val = (int)*ipopts->tos;

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

                case IP_TTL:
                        val = (int)*ipopts->ttl;

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

                break;

        case IPPROTO_IPV6:
                if (!ipsock_is_ipv6(ip))
                        break;

                switch (name) {
                case IPV6_UNICAST_HOPS:
                        val = *ipopts->ttl;

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

                case IPV6_TCLASS:
                        val = *ipopts->tos;

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

                case IPV6_V6ONLY:
                        val = !!(ip->ip_flags & IPF_V6ONLY);

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

                break;
        }

        return ENOPROTOOPT;
}

/*
 * Fill the given kinfo_pcb sysctl(7) structure with IP-level information.
 */
void
ipsock_get_info(struct kinfo_pcb * ki, const ip_addr_t * local_ip,
        uint16_t local_port, const ip_addr_t * remote_ip, uint16_t remote_port)
{
        ip_addr_t ipaddr;
        socklen_t len;
        uint8_t type;

        len = sizeof(ki->ki_spad); /* use this for the full size, not ki_src */

        addr_put_inet(&ki->ki_src, &len, local_ip, TRUE /*kame*/, local_port);

        /*
         * At this point, the local IP address type has already been used to
         * determine whether this is an IPv4 or IPv6 socket.  While not ideal,
         * that is the best we can do: we cannot use IPv4-mapped IPv6 addresses
         * in lwIP PCBs, we cannot store the original type in those PCBs, and
         * we also cannot rely on the PCB having an associated ipsock object
         * anymore.  We also cannot use the ipsock only when present: it could
         * make a TCP PCB "jump" from IPv6 to IPv4 in the netstat listing when
         * it goes into TIME_WAIT state, for example.
         *
         * So, use *only* the type of the local IP address to determine whether
         * this is an IPv4 or an IPv6 socket.  At the same time, do *not* rely
         * on the remote IP address being IPv4 for a local IPv4 address; it may
         * be of type IPADDR_TYPE_V6 for an unconnected socket bound to an
         * IPv4-mapped IPv6 address.  Pretty messy, but we're limited by what
         * lwIP offers here.  Since it's just netstat, it need not be perfect.
         */
        if ((type = IP_GET_TYPE(local_ip)) == IPADDR_TYPE_V4) {
                if (!ip_addr_isany(local_ip) || local_port != 0)
                        ki->ki_prstate = INP_BOUND;

                /*
                 * Make sure the returned socket address types are consistent.
                 * The only case where the remote IP address is not IPv4 here
                 * is when it is not set yet, so there is no need to check
                 * whether it is the 'any' address: it always is.
                 */
                if (IP_GET_TYPE(remote_ip) != IPADDR_TYPE_V4) {
                        ip_addr_set_zero_ip4(&ipaddr);

                        remote_ip = &ipaddr;
                }
        } else {
                if (!ip_addr_isany(local_ip) || local_port != 0)
                        ki->ki_prstate = IN6P_BOUND;
                if (type != IPADDR_TYPE_ANY)
                        ki->ki_pflags |= IN6P_IPV6_V6ONLY;
        }

        len = sizeof(ki->ki_dpad); /* use this for the full size, not ki_dst */

        addr_put_inet(&ki->ki_dst, &len, remote_ip, TRUE /*kame*/,
            remote_port);

        /* Check the type of the *local* IP address here.  See above. */
        if (!ip_addr_isany(remote_ip) || remote_port != 0) {
                if (type == IPADDR_TYPE_V4)
                        ki->ki_prstate = INP_CONNECTED;
                else
                        ki->ki_prstate = IN6P_CONNECTED;
        }
}