Changes in uspace/lib/c/generic/inet/addr.c [3495654:26de91a] in mainline

File:

• uspace/lib/c/generic/inet/addr.c (modified) (1 diff)

uspace/lib/c/generic/inet/addr.c

@@ -33 +33 @@
  */
 
+#include <assert.h>
 #include <errno.h>
+#include <unistd.h>
+#include <net/socket_codes.h>
 #include <inet/addr.h>
+#include <net/inet.h>
 #include <stdio.h>
+#include <malloc.h>
+#include <bitops.h>
+
+#define INET_PREFIXSTRSIZE  5
+
+#if !(defined(__BE__) ^ defined(__LE__))
+        #error The architecture must be either big-endian or little-endian.
+#endif
+
+const addr32_t addr32_broadcast_all_hosts = 0xffffffff;
+
+const addr48_t addr48_broadcast = {
+        0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+};
+
+static const addr48_t inet_addr48_solicited_node = {
+        0x33, 0x33, 0xff, 0, 0, 0
+};
+
+static const inet_addr_t inet_addr_any_addr = {
+        .version = ip_v4,
+        .addr = 0
+};
+
+static const inet_addr_t inet_addr_any_addr6 = {
+        .version = ip_v6,
+        .addr6 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+};
+
+void addr48(const addr48_t src, addr48_t dst)
+{
+        memcpy(dst, src, 6);
+}
+
+void addr128(const addr128_t src, addr128_t dst)
+{
+        memcpy(dst, src, 16);
+}
+
+/** Compare addr48.
+  *
+  * @return Non-zero if equal, zero if not equal.
+  */
+int addr48_compare(const addr48_t a, const addr48_t b)
+{
+        return memcmp(a, b, 6) == 0;
+}
+
+/** Compare addr128.
+  *
+  * @return Non-zero if equal, zero if not equal.
+  */
+int addr128_compare(const addr128_t a, const addr128_t b)
+{
+        return memcmp(a, b, 16) == 0;
+}
+
+/** Compute solicited node MAC multicast address from target IPv6 address
+ *
+ * @param ip  Target IPv6 address
+ * @param mac Solicited MAC address to be assigned
+ *
+ */
+void addr48_solicited_node(const addr128_t ip, addr48_t mac)
+{
+        memcpy(mac, inet_addr48_solicited_node, 3);
+        memcpy(mac + 3, ip + 13, 3);
+}
+
+void host2addr128_t_be(const addr128_t host, addr128_t be)
+{
+        memcpy(be, host, 16);
+}
+
+void addr128_t_be2host(const addr128_t be, addr128_t host)
+{
+        memcpy(host, be, 16);
+}
+
+void inet_addr(inet_addr_t *addr, uint8_t a, uint8_t b, uint8_t c, uint8_t d)
+{
+        addr->version = ip_v4;
+        addr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
+            ((addr32_t) c << 8) | ((addr32_t) d);
+}
+
+void inet_naddr(inet_naddr_t *naddr, uint8_t a, uint8_t b, uint8_t c, uint8_t d,
+    uint8_t prefix)
+{
+        naddr->version = ip_v4;
+        naddr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
+            ((addr32_t) c << 8) | ((addr32_t) d);
+        naddr->prefix = prefix;
+}
+
+void inet_addr6(inet_addr_t *addr, uint16_t a, uint16_t b, uint16_t c,
+    uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h)
+{
+        addr->version = ip_v6;
+        addr->addr6[0] = (a >> 8) & 0xff;
+        addr->addr6[1] = a & 0xff;
+        addr->addr6[2] = (b >> 8) & 0xff;
+        addr->addr6[3] = b & 0xff;
+        addr->addr6[4] = (c >> 8) & 0xff;
+        addr->addr6[5] = c & 0xff;
+        addr->addr6[6] = (d >> 8) & 0xff;
+        addr->addr6[7] = d & 0xff;
+        addr->addr6[8] = (e >> 8) & 0xff;
+        addr->addr6[9] = e & 0xff;
+        addr->addr6[10] = (f >> 8) & 0xff;
+        addr->addr6[11] = f & 0xff;
+        addr->addr6[12] = (g >> 8) & 0xff;
+        addr->addr6[13] = g & 0xff;
+        addr->addr6[14] = (h >> 8) & 0xff;
+        addr->addr6[15] = h & 0xff;
+}
+
+void inet_naddr6(inet_naddr_t *naddr, uint16_t a, uint16_t b, uint16_t c,
+    uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h, uint8_t prefix)
+{
+        naddr->version = ip_v6;
+        naddr->addr6[0] = (a >> 8) & 0xff;
+        naddr->addr6[1] = a & 0xff;
+        naddr->addr6[2] = (b >> 8) & 0xff;
+        naddr->addr6[3] = b & 0xff;
+        naddr->addr6[4] = (c >> 8) & 0xff;
+        naddr->addr6[5] = c & 0xff;
+        naddr->addr6[6] = (d >> 8) & 0xff;
+        naddr->addr6[7] = d & 0xff;
+        naddr->addr6[8] = (e >> 8) & 0xff;
+        naddr->addr6[9] = e & 0xff;
+        naddr->addr6[10] = (f >> 8) & 0xff;
+        naddr->addr6[11] = f & 0xff;
+        naddr->addr6[12] = (g >> 8) & 0xff;
+        naddr->addr6[13] = g & 0xff;
+        naddr->addr6[14] = (h >> 8) & 0xff;
+        naddr->addr6[15] = h & 0xff;
+        naddr->prefix = prefix;
+}
+
+/** Determine address version.
+ *
+ * @param text Address in common notation.
+ * @param af   Place to store address version.
+ *
+ * @return EOK on success, EINVAL if input is not in valid format.
+ *
+ */
+static int inet_addr_version(const char *text, ip_ver_t *ver)
+{
+        char *dot = str_chr(text, '.');
+        if (dot != NULL) {
+                *ver = ip_v4;
+                return EOK;
+        }
+
+        char *collon = str_chr(text, ':');
+        if (collon != NULL) {
+                *ver = ip_v6;
+                return EOK;
+        }
+
+        return EINVAL;
+}
+
+static int ipver_af(ip_ver_t ver)
+{
+        switch (ver) {
+        case ip_any:
+                return AF_NONE;
+        case ip_v4:
+                return AF_INET;
+        case ip_v6:
+                return AF_INET6;
+        default:
+                assert(false);
+                return EINVAL;
+        }
+}
+
+ip_ver_t ipver_from_af(int af)
+{
+        switch (af) {
+        case AF_NONE:
+                return ip_any;
+        case AF_INET:
+                return ip_v4;
+        case AF_INET6:
+                return ip_v6;
+        default:
+                assert(false);
+                return EINVAL;
+        }
+}
+
+void inet_naddr_addr(const inet_naddr_t *naddr, inet_addr_t *addr)
+{
+        addr->version = naddr->version;
+        memcpy(addr->addr6, naddr->addr6, 16);
+}
+
+void inet_addr_naddr(const inet_addr_t *addr, uint8_t prefix,
+    inet_naddr_t *naddr)
+{
+        naddr->version = addr->version;
+        memcpy(naddr->addr6, addr->addr6, 16);
+        naddr->prefix = prefix;
+}
+
+void inet_addr_any(inet_addr_t *addr)
+{
+        addr->version = ip_any;
+        memset(addr->addr6, 0, 16);
+}
+
+void inet_naddr_any(inet_naddr_t *naddr)
+{
+        naddr->version = ip_any;
+        memset(naddr->addr6, 0, 16);
+        naddr->prefix = 0;
+}
+
+int inet_addr_compare(const inet_addr_t *a, const inet_addr_t *b)
+{
+        if (a->version != b->version)
+                return 0;
+
+        switch (a->version) {
+        case ip_v4:
+                return (a->addr == b->addr);
+        case ip_v6:
+                return addr128_compare(a->addr6, b->addr6);
+        default:
+                return 0;
+        }
+}
+
+int inet_addr_is_any(const inet_addr_t *addr)
+{
+        return ((addr->version == ip_any) ||
+            (inet_addr_compare(addr, &inet_addr_any_addr)) ||
+            (inet_addr_compare(addr, &inet_addr_any_addr6)));
+}
+
+int inet_naddr_compare(const inet_naddr_t *naddr, const inet_addr_t *addr)
+{
+        if (naddr->version != addr->version)
+                return 0;
+        
+        switch (naddr->version) {
+        case ip_v4:
+                return (naddr->addr == addr->addr);
+        case ip_v6:
+                return addr128_compare(naddr->addr6, addr->addr6);
+        default:
+                return 0;
+        }
+}
+
+int inet_naddr_compare_mask(const inet_naddr_t *naddr, const inet_addr_t *addr)
+{
+        if (naddr->version != addr->version)
+                return 0;
+
+        switch (naddr->version) {
+        case ip_v4:
+                if (naddr->prefix > 32)
+                        return 0;
+
+                addr32_t mask =
+                    BIT_RANGE(addr32_t, 31, 31 - (naddr->prefix - 1));
+                return ((naddr->addr & mask) == (addr->addr & mask));
+        case ip_v6:
+                if (naddr->prefix > 128)
+                        return 0;
+                
+                size_t pos = 0;
+                for (size_t i = 0; i < 16; i++) {
+                        /* Further bits do not matter */
+                        if (naddr->prefix < pos)
+                                break;
+                        
+                        if (naddr->prefix - pos > 8) {
+                                /* Comparison without masking */
+                                if (naddr->addr6[i] != addr->addr6[i])
+                                        return 0;
+                        } else {
+                                /* Comparison with masking */
+                                uint8_t mask =
+                                    BIT_RANGE(uint8_t, 8, 8 - (naddr->prefix - pos - 1));
+                                if ((naddr->addr6[i] & mask) != (addr->addr6[i] & mask))
+                                        return 0;
+                        }
+                        
+                        pos += 8;
+                }
+                
+                return 1;
+        default:
+                return 0;
+        }
+}
+
+/** Parse node address.
+ *
+ * @param text Network address in common notation.
+ * @param addr Place to store node address.
+ *
+ * @return EOK on success, EINVAL if input is not in valid format.
+ *
+ */
+int inet_addr_parse(const char *text, inet_addr_t *addr)
+{
+        int rc = inet_addr_version(text, &addr->version);
+        if (rc != EOK)
+                return rc;
+        
+        uint8_t buf[16];
+        rc = inet_pton(ipver_af(addr->version), text, buf);
+        if (rc != EOK)
+                return rc;
+        
+        switch (addr->version) {
+        case ip_v4:
+                addr->addr = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) |
+                    buf[3];
+                break;
+        case ip_v6:
+                memcpy(addr->addr6, buf, 16);
+                break;
+        default:
+                return EINVAL;
+        }
+        
+        return EOK;
+}
 
 /** Parse network address.
  *
- * @param text  Network address in CIDR notation (a.b.c.d/w)
- * @param naddr Place to store network address
- *
- * @return      EOK on success, EINVAL if input is not in valid format
+ * @param text  Network address in common notation.
+ * @param naddr Place to store network address.
+ *
+ * @return EOK on success, EINVAL if input is not in valid format.
+ *
  */
 int inet_naddr_parse(const char *text, inet_naddr_t *naddr)
 {
-        unsigned long a[4], bits;
-        char *cp = (char *)text;
-        int i;
-
-        for (i = 0; i < 3; i++) {
-                a[i] = strtoul(cp, &cp, 10);
-                if (*cp != '.')
+        char *slash = str_chr(text, '/');
+        if (slash == NULL)
+                return EINVAL;
+        
+        *slash = 0;
+        
+        int rc = inet_addr_version(text, &naddr->version);
+        if (rc != EOK)
+                return rc;
+        
+        uint8_t buf[16];
+        rc = inet_pton(ipver_af(naddr->version), text, buf);
+        *slash = '/';
+        
+        if (rc != EOK)
+                return rc;
+        
+        slash++;
+        uint8_t prefix;
+        
+        switch (naddr->version) {
+        case ip_v4:
+                prefix = strtoul(slash, &slash, 10);
+                if (prefix > 32)
                         return EINVAL;
-                ++cp;
-        }
-
-        a[3] = strtoul(cp, &cp, 10);
-        if (*cp != '/')
-                return EINVAL;
-        ++cp;
-
-        bits = strtoul(cp, &cp, 10);
-        if (*cp != '\0')
-                return EINVAL;
-
-        naddr->ipv4 = 0;
-        for (i = 0; i < 4; i++) {
-                if (a[i] > 255)
+                
+                naddr->addr = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) |
+                    buf[3];
+                naddr->prefix = prefix;
+                
+                break;
+        case ip_v6:
+                prefix = strtoul(slash, &slash, 10);
+                if (prefix > 128)
                         return EINVAL;
-                naddr->ipv4 = (naddr->ipv4 << 8) | a[i];
-        }
-
-        if (bits > 31)
-                return EINVAL;
-
-        naddr->bits = bits;
+                
+                memcpy(naddr->addr6, buf, 16);
+                naddr->prefix = prefix;
+                
+                break;
+        default:
+                return ENOTSUP;
+        }
+        
         return EOK;
 }
 
-/** Parse node address.
- *
- * @param text  Network address in dot notation (a.b.c.d)
- * @param addr  Place to store node address
- *
- * @return      EOK on success, EINVAL if input is not in valid format
- */
-int inet_addr_parse(const char *text, inet_addr_t *addr)
-{
-        unsigned long a[4];
-        char *cp = (char *)text;
-        int i;
-
-        for (i = 0; i < 3; i++) {
-                a[i] = strtoul(cp, &cp, 10);
-                if (*cp != '.')
-                        return EINVAL;
-                ++cp;
-        }
-
-        a[3] = strtoul(cp, &cp, 10);
-        if (*cp != '\0')
-                return EINVAL;
-
-        addr->ipv4 = 0;
-        for (i = 0; i < 4; i++) {
-                if (a[i] > 255)
-                        return EINVAL;
-                addr->ipv4 = (addr->ipv4 << 8) | a[i];
-        }
-
-        return EOK;
-}
-
-/** Format network address.
- *
- * @param naddr Network address
- * @param bufp  Place to store pointer to formatted string (CIDR notation)
- *
- * @return      EOK on success, ENOMEM if out of memory.
- */
-int inet_naddr_format(inet_naddr_t *naddr, char **bufp)
-{
-        int rc;
-
-        rc = asprintf(bufp, "%d.%d.%d.%d/%d", naddr->ipv4 >> 24,
-            (naddr->ipv4 >> 16) & 0xff, (naddr->ipv4 >> 8) & 0xff,
-            naddr->ipv4 & 0xff, naddr->bits);
-
+/** Format node address.
+ *
+ * @param addr Node address.
+ * @param bufp Place to store pointer to formatted string.
+ *
+ * @return EOK on success.
+ * @return ENOMEM if out of memory.
+ * @return ENOTSUP on unsupported address family.
+ *
+ */
+int inet_addr_format(const inet_addr_t *addr, char **bufp)
+{
+        int rc = 0;
+        
+        switch (addr->version) {
+        case ip_any:
+                rc = asprintf(bufp, "none");
+                break;
+        case ip_v4:
+                rc = asprintf(bufp, "%u.%u.%u.%u", (addr->addr >> 24) & 0xff,
+                    (addr->addr >> 16) & 0xff, (addr->addr >> 8) & 0xff,
+                    addr->addr & 0xff);
+                break;
+        case ip_v6:
+                *bufp = (char *) malloc(INET6_ADDRSTRLEN);
+                if (*bufp == NULL)
+                        return ENOMEM;
+                
+                return inet_ntop(AF_INET6, addr->addr6, *bufp, INET6_ADDRSTRLEN);
+        default:
+                return ENOTSUP;
+        }
+        
         if (rc < 0)
                 return ENOMEM;
-
+        
         return EOK;
 }
 
-/** Format node address.
- *
- * @param addr  Node address
- * @param bufp  Place to store pointer to formatted string (dot notation)
- *
- * @return      EOK on success, ENOMEM if out of memory.
- */
-int inet_addr_format(inet_addr_t *addr, char **bufp)
-{
-        int rc;
-
-        rc = asprintf(bufp, "%d.%d.%d.%d", addr->ipv4 >> 24,
-            (addr->ipv4 >> 16) & 0xff, (addr->ipv4 >> 8) & 0xff,
-            addr->ipv4 & 0xff);
-
+/** Format network address.
+ *
+ * @param naddr Network address.
+ * @param bufp  Place to store pointer to formatted string.
+ *
+ * @return EOK on success.
+ * @return ENOMEM if out of memory.
+ * @return ENOTSUP on unsupported address family.
+ *
+ */
+int inet_naddr_format(const inet_naddr_t *naddr, char **bufp)
+{
+        int rc = 0;
+        char prefix[INET_PREFIXSTRSIZE];
+        
+        switch (naddr->version) {
+        case ip_any:
+                rc = asprintf(bufp, "none");
+                break;
+        case ip_v4:
+                rc = asprintf(bufp, "%" PRIu8 ".%" PRIu8 ".%" PRIu8 ".%" PRIu8
+                    "/%" PRIu8, (naddr->addr >> 24) & 0xff,
+                    (naddr->addr >> 16) & 0xff, (naddr->addr >> 8) & 0xff,
+                    naddr->addr & 0xff, naddr->prefix);
+                break;
+        case ip_v6:
+                *bufp = (char *) malloc(INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE);
+                if (*bufp == NULL)
+                        return ENOMEM;
+                
+                rc = inet_ntop(AF_INET6, naddr->addr6, *bufp,
+                    INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE);
+                if (rc != EOK) {
+                        free(*bufp);
+                        return rc;
+                }
+                
+                rc = snprintf(prefix, INET_PREFIXSTRSIZE, "/%" PRIu8,
+                    naddr->prefix);
+                if (rc < 0) {
+                        free(*bufp);
+                        return ENOMEM;
+                }
+                
+                str_append(*bufp, INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE, prefix);
+                
+                break;
+        default:
+                return ENOTSUP;
+        }
+        
         if (rc < 0)
                 return ENOMEM;
-
+        
         return EOK;
 }
 
+ip_ver_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6)
+{
+        switch (addr->version) {
+        case ip_v4:
+                if (v4 != NULL)
+                        *v4 = addr->addr;
+                break;
+        case ip_v6:
+                if (v6 != NULL)
+                        memcpy(*v6, addr->addr6, 16);
+                break;
+        default:
+                assert(false);
+                break;
+        }
+
+        return addr->version;
+}
+
+ip_ver_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6,
+    uint8_t *prefix)
+{
+        switch (naddr->version) {
+        case ip_v4:
+                if (v4 != NULL)
+                        *v4 = naddr->addr;
+                if (prefix != NULL)
+                        *prefix = naddr->prefix;
+                break;
+        case ip_v6:
+                if (v6 != NULL)
+                        memcpy(*v6, naddr->addr6, 16);
+                if (prefix != NULL)
+                        *prefix = naddr->prefix;
+                break;
+        default:
+                assert(false);
+                break;
+        }
+
+        return naddr->version;
+}
+
+void inet_addr_set(addr32_t v4, inet_addr_t *addr)
+{
+        addr->version = ip_v4;
+        addr->addr = v4;
+}
+
+void inet_naddr_set(addr32_t v4, uint8_t prefix, inet_naddr_t *naddr)
+{
+        naddr->version = ip_v4;
+        naddr->addr = v4;
+        naddr->prefix = prefix;
+}
+
+void inet_sockaddr_in_addr(const sockaddr_in_t *sockaddr_in, inet_addr_t *addr)
+{
+        addr->version = ip_v4;
+        addr->addr = uint32_t_be2host(sockaddr_in->sin_addr.s_addr);
+}
+
+void inet_addr_set6(addr128_t v6, inet_addr_t *addr)
+{
+        addr->version = ip_v6;
+        memcpy(addr->addr6, v6, 16);
+}
+
+void inet_naddr_set6(addr128_t v6, uint8_t prefix, inet_naddr_t *naddr)
+{
+        naddr->version = ip_v6;
+        memcpy(naddr->addr6, v6, 16);
+        naddr->prefix = prefix;
+}
+
+void inet_sockaddr_in6_addr(const sockaddr_in6_t *sockaddr_in6,
+    inet_addr_t *addr)
+{
+        addr->version = ip_v6;
+        addr128_t_be2host(sockaddr_in6->sin6_addr.s6_addr, addr->addr6);
+}
+
+uint16_t inet_addr_sockaddr_in(const inet_addr_t *addr,
+    sockaddr_in_t *sockaddr_in, sockaddr_in6_t *sockaddr_in6)
+{
+        switch (addr->version) {
+        case ip_v4:
+                if (sockaddr_in != NULL) {
+                        sockaddr_in->sin_family = AF_INET;
+                        sockaddr_in->sin_addr.s_addr = host2uint32_t_be(addr->addr);
+                }
+                break;
+        case ip_v6:
+                if (sockaddr_in6 != NULL) {
+                        sockaddr_in6->sin6_family = AF_INET6;
+                        host2addr128_t_be(addr->addr6, sockaddr_in6->sin6_addr.s6_addr);
+                }
+                break;
+        default:
+                assert(false);
+                break;
+        }
+
+        return ipver_af(addr->version);
+}
+
+int inet_addr_sockaddr(const inet_addr_t *addr, uint16_t port,
+    sockaddr_t **nsockaddr, socklen_t *naddrlen)
+{
+        sockaddr_in_t *sa4;
+        sockaddr_in6_t *sa6;
+
+        switch (addr->version) {
+        case ip_v4:
+                sa4 = calloc(1, sizeof(sockaddr_in_t));
+                if (sa4 == NULL)
+                        return ENOMEM;
+
+                sa4->sin_family = AF_INET;
+                sa4->sin_port = host2uint16_t_be(port);
+                sa4->sin_addr.s_addr = host2uint32_t_be(addr->addr);
+                if (nsockaddr != NULL)
+                        *nsockaddr = (sockaddr_t *)sa4;
+                if (naddrlen != NULL)
+                        *naddrlen = sizeof(*sa4);
+                break;
+        case ip_v6:
+                sa6 = calloc(1, sizeof(sockaddr_in6_t));
+                if (sa6 == NULL)
+                        return ENOMEM;
+
+                sa6->sin6_family = AF_INET6;
+                sa6->sin6_port = host2uint16_t_be(port);
+                host2addr128_t_be(addr->addr6, sa6->sin6_addr.s6_addr);
+                if (nsockaddr != NULL)
+                        *nsockaddr = (sockaddr_t *)sa6;
+                if (naddrlen != NULL)
+                        *naddrlen = sizeof(*sa6);
+                break;
+        default:
+                assert(false);
+                break;
+        }
+
+        return EOK;
+}
+
 /** @}
  */