Add basic IPv6 definitions as sfdnsres seems to support it...

...also fix a bug in the inet_* functions.

nx/include/netinet/in.h

@@ -569,9 +569,115 @@ struct group_source_req {
 
 /* INET6 stuff */
 #if __POSIX_VISIBLE >= 200112
-#define	__KAME_NETINET_IN_H_INCLUDED_
+// TuxSH: modified
-//#include <netinet6/in6.h>
+
-#undef __KAME_NETINET_IN_H_INCLUDED_
+#define INET6_ADDRSTRLEN 46
+
+// For compliance:
+
+#define IPV6_UNICAST_HOPS	4  /* int; IP6 hops */
+#define IPV6_MULTICAST_IF	9  /* u_int; set/get IP6 multicast i/f  */
+#define IPV6_MULTICAST_HOPS	10 /* int; set/get IP6 multicast hops */
+#define IPV6_MULTICAST_LOOP	11 /* u_int; set/get IP6 multicast loopback */
+#define IPV6_JOIN_GROUP		12 /* ipv6_mreq; join a group membership */
+#define IPV6_LEAVE_GROUP	13 /* ipv6_mreq; leave a group membership */
+#define IPV6_PORTRANGE		14 /* int; range to choose for unspec port */
+#define IPV6_V6ONLY		27 /* bool; make AF_INET6 sockets v6 only */
+
+/*
+ * Unspecified
+ */
+#define IN6_IS_ADDR_UNSPECIFIED(a)	\
+	((a)->__u6_addr.__u6_addr32[0] == 0 &&	\
+	 (a)->__u6_addr.__u6_addr32[1] == 0 &&	\
+	 (a)->__u6_addr.__u6_addr32[2] == 0 &&	\
+	 (a)->__u6_addr.__u6_addr32[3] == 0)
+
+/*
+ * Loopback
+ */
+#define IN6_IS_ADDR_LOOPBACK(a)		\
+	((a)->__u6_addr.__u6_addr32[0] == 0 &&	\
+	 (a)->__u6_addr.__u6_addr32[1] == 0 &&	\
+	 (a)->__u6_addr.__u6_addr32[2] == 0 &&	\
+	 (a)->__u6_addr.__u6_addr32[3] == ntohl(1))
+
+/*
+ * IPv4 compatible
+ */
+#define IN6_IS_ADDR_V4COMPAT(a)		\
+	((a)->__u6_addr.__u6_addr32[0] == 0 &&	\
+	 (a)->__u6_addr.__u6_addr32[1] == 0 &&	\
+	 (a)->__u6_addr.__u6_addr32[2] == 0 &&	\
+	 (a)->__u6_addr.__u6_addr32[3] != 0 &&	\
+	 (a)->__u6_addr.__u6_addr32[3] != ntohl(1))
+
+/*
+ * Mapped
+ */
+#define IN6_IS_ADDR_V4MAPPED(a)		      \
+	((a)->__u6_addr.__u6_addr32[0] == 0 &&	\
+	 (a)->__u6_addr.__u6_addr32[1] == 0 &&	\
+	 (a)->__u6_addr.__u6_addr32[2] == ntohl(0x0000ffff))
+
+#define __IPV6_ADDR_SCOPE_NODELOCAL	0x01
+#define __IPV6_ADDR_SCOPE_INTFACELOCAL	0x01
+#define __IPV6_ADDR_SCOPE_LINKLOCAL	0x02
+#define __IPV6_ADDR_SCOPE_SITELOCAL	0x05
+#define __IPV6_ADDR_SCOPE_ORGLOCAL	0x08	/* just used in this file */
+#define __IPV6_ADDR_SCOPE_GLOBAL	0x0e
+
+/*
+ * Unicast Scope
+ * Note that we must check topmost 10 bits only, not 16 bits (see RFC2373).
+ */
+#define IN6_IS_ADDR_LINKLOCAL(a)	\
+	(((a)->s6_addr[0] == 0xfe) && (((a)->s6_addr[1] & 0xc0) == 0x80))
+#define IN6_IS_ADDR_SITELOCAL(a)	\
+	(((a)->s6_addr[0] == 0xfe) && (((a)->s6_addr[1] & 0xc0) == 0xc0))
+
+/*
+ * Multicast
+ */
+#define IN6_IS_ADDR_MULTICAST(a)	((a)->s6_addr[0] == 0xff)
+
+#define __IPV6_ADDR_MC_SCOPE(a)		((a)->s6_addr[1] & 0x0f)
+
+#define IN6_IS_ADDR_MC_NODELOCAL(a)	\
+	(IN6_IS_ADDR_MULTICAST(a) &&	\
+	 (__IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_NODELOCAL))
+#define IN6_IS_ADDR_MC_LINKLOCAL(a)	\
+	(IN6_IS_ADDR_MULTICAST(a) &&	\
+	 (__IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_LINKLOCAL))
+#define IN6_IS_ADDR_MC_SITELOCAL(a)	\
+	(IN6_IS_ADDR_MULTICAST(a) &&	\
+	 (__IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_SITELOCAL))
+#define IN6_IS_ADDR_MC_ORGLOCAL(a)	\
+	(IN6_IS_ADDR_MULTICAST(a) &&	\
+	 (__IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_ORGLOCAL))
+#define IN6_IS_ADDR_MC_GLOBAL(a)	\
+	(IN6_IS_ADDR_MULTICAST(a) &&	\
+	 (__IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_GLOBAL))
+
+struct in6_addr {
+	union {
+		uint16_t	__u6_addr16[8];
+		uint32_t	__u6_addr32[4];
+		unsigned char   s6_addr[16];   /* IPv6 address */
+	};
+};
+
+struct sockaddr_in6 {
+	sa_family_t     sin6_family;   /* AF_INET6 */
+	in_port_t       sin6_port;     /* port number */
+	uint32_t        sin6_flowinfo; /* IPv6 flow information */
+	struct in6_addr sin6_addr;     /* IPv6 address */
+	uint32_t        sin6_scope_id; /* Scope ID */
+};
+
+extern const struct in6_addr in6addr_any;
+extern const struct in6_addr in6addr_loopback;
+
 #endif
 
 #endif /* !_NETINET_IN_H_*/

nx/source/runtime/devices/socket.c

@@ -15,6 +15,7 @@
 #include <fcntl.h>
 #include <sys/ioctl.h>
 #include <sys/sysctl.h>
+#include <netinet/in.h>
 #include <net/bpf.h>
 
 #include <arpa/inet.h>
@@ -23,6 +24,9 @@
 #include "services/bsd.h"
 #include "result.h"
 
+const struct in6_addr in6addr_any = {0};
+const struct in6_addr in6addr_loopback = {.__u6_addr32 = {0, 0, 0, __builtin_bswap32(1)}};
+
 static int _socketOpen(struct _reent *r, void *fdptr, const char *path, int flags, int mode);
 static int _socketClose(struct _reent *r, void *fdptr);
 static ssize_t _socketWrite(struct _reent *r, void *fdptr, const char *buf, size_t count);
@@ -234,6 +238,274 @@ static int _socketInetAtonDetail(int *outBase, size_t *outNumBytes, const char *
     return 1;
 }
 
+// Adapted from ctrulib
+static const char *inet_ntop4(const void *src, char *dst, socklen_t size) {
+    const u8 *ip = src;
+
+    char *p;
+    size_t i;
+    unsigned int n;
+
+    if(size < INET_ADDRSTRLEN) {
+        errno = ENOSPC;
+        return NULL;
+    }
+
+    for(p = dst, i = 0; i < 4; ++i) {
+        if(i > 0) *p++ = '.';
+
+        n = ip[i];
+        if(n >= 100) {
+            *p++ = n/100 + '0';
+            n %= 100;
+        }
+        if(n >= 10 || ip[i] >= 100) {
+            *p++ = n/10 + '0';
+            n %= 10;
+        }
+        *p++ = n + '0';
+    }
+    *p = 0;
+
+    return dst;
+}
+
+static int inet_pton4(const char *src, void *dst) {
+    int base;
+    size_t numBytes;
+
+    int ret = _socketInetAtonDetail(&base, &numBytes, src, (struct in_addr *)dst);
+    return (ret == 1 && base == 10 && numBytes == 4) ? 1 : 0;
+}
+
+// ==============================================================
+
+/* Copyright (c) 1996 by Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
+ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
+ * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ */
+
+#define INADDRSZ 4
+#define IN6ADDRSZ 16
+#define INT16SZ 2
+/* const char *
+ * inet_ntop6(src, dst, size)
+ *	convert IPv6 binary address into presentation (printable) format
+ * author:
+ *	Paul Vixie, 1996.
+ */
+static const char *
+inet_ntop6(src, dst, size)
+    const u_char *src;
+    char *dst;
+    size_t size;
+{
+    /*
+     * Note that int32_t and int16_t need only be "at least" large enough
+     * to contain a value of the specified size.  On some systems, like
+     * Crays, there is no such thing as an integer variable with 16 bits.
+     * Keep this in mind if you think this function should have been coded
+     * to use pointer overlays.  All the world's not a VAX.
+     */
+    char tmp[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"], *tp;
+    struct { int base, len; } best = {0}, cur = {0};
+    u_int words[IN6ADDRSZ / INT16SZ];
+    int i;
+
+    /*
+     * Preprocess:
+     *	Copy the input (bytewise) array into a wordwise array.
+     *	Find the longest run of 0x00's in src[] for :: shorthanding.
+     */
+    memset(words, 0, sizeof words);
+    for (i = 0; i < IN6ADDRSZ; i++)
+        words[i / 2] |= (src[i] << ((1 - (i % 2)) << 3));
+    best.base = -1;
+    cur.base = -1;
+    for (i = 0; i < (IN6ADDRSZ / INT16SZ); i++) {
+        if (words[i] == 0) {
+            if (cur.base == -1)
+                cur.base = i, cur.len = 1;
+            else
+                cur.len++;
+        } else {
+            if (cur.base != -1) {
+                if (best.base == -1 || cur.len > best.len)
+                    best = cur;
+                cur.base = -1;
+            }
+        }
+    }
+    if (cur.base != -1) {
+        if (best.base == -1 || cur.len > best.len)
+            best = cur;
+    }
+    if (best.base != -1 && best.len < 2)
+        best.base = -1;
+
+    /*
+     * Format the result.
+     */
+    tp = tmp;
+    for (i = 0; i < (IN6ADDRSZ / INT16SZ); i++) {
+        /* Are we inside the best run of 0x00's? */
+        if (best.base != -1 && i >= best.base &&
+            i < (best.base + best.len)) {
+            if (i == best.base)
+                *tp++ = ':';
+            continue;
+        }
+        /* Are we following an initial run of 0x00s or any real hex? */
+        if (i != 0)
+            *tp++ = ':';
+        /* Is this address an encapsulated IPv4? */
+        if (i == 6 && best.base == 0 &&
+            (best.len == 6 || (best.len == 5 && words[5] == 0xffff))) {
+            if (!inet_ntop4(src+12, tp, sizeof tmp - (tp - tmp)))
+                return (NULL);
+            tp += strlen(tp);
+            break;
+        }
+        //TuxSH:
+        //sprintf(tp, "%x", words[i]);
+        {
+            char *e = tp + 7;
+            memset(e, '0', 4);
+            u_int word = words[i];
+            while(word > 0) {
+                static const char digits[] = "0123456789abcdef";
+                *e-- = digits[word & 0xF];
+                word >>= 4;
+            }
+        }
+        tp += strlen(tp);
+    }
+    /* Was it a trailing run of 0x00's? */
+    if (best.base != -1 && (best.base + best.len) == (IN6ADDRSZ / INT16SZ))
+        *tp++ = ':';
+    *tp++ = '\0';
+
+    /*
+     * Check for overflow, copy, and we're done.
+     */
+    if ((tp - tmp) > size) {
+        errno = ENOSPC;
+        return (NULL);
+    }
+    strcpy(dst, tmp);
+    return (dst);
+}
+
+/* int
+ * inet_pton6(src, dst)
+ *	convert presentation level address to network order binary form.
+ * return:
+ *	1 if `src' is a valid [RFC1884 2.2] address, else 0.
+ * notice:
+ *	(1) does not touch `dst' unless it's returning 1.
+ *	(2) :: in a full address is silently ignored.
+ * credit:
+ *	inspired by Mark Andrews.
+ * author:
+ *	Paul Vixie, 1996.
+ */
+static int
+inet_pton6(src, dst)
+    const char *src;
+    u_char *dst;
+{
+    static const char xdigits_l[] = "0123456789abcdef",
+              xdigits_u[] = "0123456789ABCDEF";
+    u_char tmp[IN6ADDRSZ], *tp, *endp, *colonp;
+    const char *xdigits, *curtok;
+    int ch, saw_xdigit;
+    u_int val;
+
+    memset((tp = tmp), 0, IN6ADDRSZ);
+    endp = tp + IN6ADDRSZ;
+    colonp = NULL;
+    /* Leading :: requires some special handling. */
+    if (*src == ':')
+        if (*++src != ':')
+            return (0);
+    curtok = src;
+    saw_xdigit = 0;
+    val = 0;
+    while ((ch = *src++) != '\0') {
+        const char *pch;
+
+        if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL)
+            pch = strchr((xdigits = xdigits_u), ch);
+        if (pch != NULL) {
+            val <<= 4;
+            val |= (pch - xdigits);
+            if (val > 0xffff)
+                return (0);
+            saw_xdigit = 1;
+            continue;
+        }
+        if (ch == ':') {
+            curtok = src;
+            if (!saw_xdigit) {
+                if (colonp)
+                    return (0);
+                colonp = tp;
+                continue;
+            }
+            if (tp + INT16SZ > endp)
+                return (0);
+            *tp++ = (u_char) (val >> 8) & 0xff;
+            *tp++ = (u_char) val & 0xff;
+            saw_xdigit = 0;
+            val = 0;
+            continue;
+        }
+        if (ch == '.' && ((tp + INADDRSZ) <= endp) &&
+            inet_pton4(curtok, tp) > 0) {
+            tp += INADDRSZ;
+            saw_xdigit = 0;
+            break;	/* '\0' was seen by inet_pton4(). */
+        }
+        return (0);
+    }
+    if (saw_xdigit) {
+        if (tp + INT16SZ > endp)
+            return (0);
+        *tp++ = (u_char) (val >> 8) & 0xff;
+        *tp++ = (u_char) val & 0xff;
+    }
+    if (colonp != NULL) {
+        /*
+         * Since some memmove()'s erroneously fail to handle
+         * overlapping regions, we'll do the shift by hand.
+         */
+        const int n = tp - colonp;
+        int i;
+
+        for (i = 1; i <= n; i++) {
+            endp[- i] = colonp[n - i];
+            colonp[n - i] = 0;
+        }
+        tp = endp;
+    }
+    if (tp != endp)
+        return (0);
+    /* bcopy(tmp, dst, IN6ADDRSZ); */
+    memcpy(dst, tmp, IN6ADDRSZ);
+    return (1);
+}
+// ==============================================================
 
 const SocketInitConfig *socketGetDefaultInitConfig(void) {
     return &g_defaultSocketInitConfig;
@@ -712,48 +984,28 @@ int recvmmsg(int sockfd, struct mmsghdr *msgvec, unsigned int vlen, int flags, s
     return -1;
 }
 
-// Adapted from ctrulib
 const char *inet_ntop(int af, const void *src, char *dst, socklen_t size) {
-    const u8 *ip = src;
+    switch(af) {
-
+        case AF_INET:
-    char *p;
+            return inet_ntop4(src, dst, size);
-    size_t i;
+        case AF_INET6:
-    unsigned int n;
+            return inet_ntop6(src, dst, size);
-
+        default:
-    if(af == AF_INET) {
             errno = EAFNOSUPPORT;
             return NULL;
     }
-    if(size < INET_ADDRSTRLEN) {
-        errno = ENOSPC;
-        return NULL;
-    }
-
-    for(p = dst, i = 0; i < 4; ++i) {
-        if(i > 0) *p++ = '.';
-
-        n = ip[i];
-        if(n >= 100) {
-            *p++ = n/100 + '0';
-            n %= 100;
-        }
-        if(n >= 10 || ip[i] >= 100) {
-            *p++ = n/10 + '0';
-            n %= 10;
-        }
-        *p++ = n + '0';
-    }
-    *p = 0;
-
-    return dst;
 }
 
 int inet_pton(int af, const char *src, void *dst) {
-    int base;
+    switch(af) {
-    size_t numBytes;
+        case AF_INET:
-
+            return inet_pton4(src, dst);
-    int ret = _socketInetAtonDetail(&base, &numBytes, src, (struct in_addr *)dst);
+        case AF_INET6:
-    return (ret == 1 && base == 10 && numBytes == 4) ? 1 : 0;
+            return inet_pton6(src, dst);
+        default:
+            errno = EAFNOSUPPORT;
+            return -1;
+    }
 }
 
 char *inet_ntoa(struct in_addr in) {