Changeset fb4d788 in mainline for uspace/lib/c/generic/inet/addr.c

Timestamp:

2015-07-28T11:28:14Z (9 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

6accc5cf

Parents:

df2bce3 (diff), 47726b5e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge from the mainline

File:

• uspace/lib/c/generic/inet/addr.c (modified) (15 diffs)

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2013 Jiri Svoboda
+ * Copyright (c) 2013 Martin Decky
  * All rights reserved.
  *
@@ -36 +37 @@
 #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>
@@ -44 +43 @@
 
 #define INET_PREFIXSTRSIZE  5
+
+#define INET6_ADDRSTRLEN (8 * 4 + 7 + 1)
 
 #if !(defined(__BE__) ^ defined(__LE__))
@@ -180 +181 @@
 }
 
-/** 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)
 {
@@ -288 +234 @@
         if (naddr->version != addr->version)
                 return 0;
-        
+
         switch (naddr->version) {
         case ip_v4:
@@ -315 +261 @@
                 if (naddr->prefix > 128)
                         return 0;
-                
+
                 size_t pos = 0;
                 for (size_t i = 0; i < 16; i++) {
@@ -321 +267 @@
                         if (naddr->prefix < pos)
                                 break;
-                        
+
                         if (naddr->prefix - pos > 8) {
                                 /* Comparison without masking */
@@ -333 +279 @@
                                         return 0;
                         }
-                        
+
                         pos += 8;
                 }
-                
+
                 return 1;
         default:
@@ -343 +289 @@
 }
 
+static int inet_addr_parse_v4(const char *str, inet_addr_t *raddr,
+    int *prefix)
+{
+        uint32_t a = 0;
+        uint8_t b;
+        char *cur = (char *)str;
+        size_t i = 0;
+
+        while (i < 4) {
+                int rc = str_uint8_t(cur, (const char **)&cur, 10, false, &b);
+                if (rc != EOK)
+                        return rc;
+
+                a = (a << 8) + b;
+
+                i++;
+
+                if (*cur == '\0' || *cur == '/')
+                        break;
+
+                if (*cur != '.')
+                        return EINVAL;
+
+                if (i < 4)
+                        cur++;
+        }
+
+        if (prefix != NULL) {
+                if (*cur != '/')
+                        return EINVAL;
+                cur++;
+
+                *prefix = strtoul(cur, &cur, 10);
+                if (*prefix > 32)
+                        return EINVAL;
+        }
+
+        if (i != 4 || (*cur != '\0'))
+                return EINVAL;
+
+        raddr->version = ip_v4;
+        raddr->addr = a;
+
+        return EOK;
+}
+
+static int inet_addr_parse_v6(const char *str, inet_addr_t *raddr, int *prefix)
+{
+        uint8_t data[16];
+
+        memset(data, 0, 16);
+
+        const char *cur = str;
+        size_t i = 0;
+        size_t wildcard_pos = (size_t) -1;
+        size_t wildcard_size = 0;
+
+        /* Handle initial wildcard */
+        if ((str[0] == ':') && (str[1] == ':')) {
+                cur = str + 2;
+                wildcard_pos = 0;
+                wildcard_size = 16;
+
+                /* Handle the unspecified address */
+                if (*cur == '\0')
+                        goto success;
+        }
+
+        while (i < 16) {
+                uint16_t bioctet;
+                int rc = str_uint16_t(cur, &cur, 16, false, &bioctet);
+                if (rc != EOK)
+                        return rc;
+
+                data[i] = (bioctet >> 8) & 0xff;
+                data[i + 1] = bioctet & 0xff;
+
+                if (wildcard_pos != (size_t) -1) {
+                        if (wildcard_size < 2)
+                                return EINVAL;
+
+                        wildcard_size -= 2;
+                }
+
+                i += 2;
+
+                if (*cur != ':')
+                        break;
+
+                if (i < 16) {
+                        cur++;
+
+                        /* Handle wildcard */
+                        if (*cur == ':') {
+                                if (wildcard_pos != (size_t) -1)
+                                        return EINVAL;
+
+                                wildcard_pos = i;
+                                wildcard_size = 16 - i;
+                                cur++;
+
+                                if (*cur == '\0' || *cur == '/')
+                                        break;
+                        }
+                }
+        }
+
+        if (prefix != NULL) {
+                if (*cur != '/')
+                        return EINVAL;
+                cur++;
+
+                *prefix = strtoul(cur, (char **)&cur, 10);
+                if (*prefix > 128)
+                        return EINVAL;
+        }
+
+        if (*cur != '\0')
+                return EINVAL;
+
+        /* Create wildcard positions */
+        if ((wildcard_pos != (size_t) -1) && (wildcard_size > 0)) {
+                size_t wildcard_shift = 16 - wildcard_size;
+
+                for (i = wildcard_pos + wildcard_shift; i > wildcard_pos; i--) {
+                        size_t j = i - 1;
+                        data[j + wildcard_size] = data[j];
+                        data[j] = 0;
+                }
+        }
+
+success:
+        raddr->version = ip_v6;
+        memcpy(raddr->addr6, data, 16);
+        return EOK;
+}
+
 /** Parse node address.
  *
@@ -353 +436 @@
 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;
+        int rc;
+
+        rc = inet_addr_parse_v4(text, addr, NULL);
+        if (rc == EOK)
+                return EOK;
+
+        rc = inet_addr_parse_v6(text, addr, NULL);
+        if (rc == EOK)
+                return EOK;
+
+        return EINVAL;
 }
 
@@ -387 +459 @@
 int inet_naddr_parse(const char *text, inet_naddr_t *naddr)
 {
-        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)
+        int rc;
+        inet_addr_t addr;
+        int prefix;
+
+        rc = inet_addr_parse_v4(text, &addr, &prefix);
+        if (rc == EOK) {
+                inet_addr_naddr(&addr, prefix, naddr);
+                return EOK;
+        }
+
+        rc = inet_addr_parse_v6(text, &addr, &prefix);
+        if (rc == EOK) {
+                inet_addr_naddr(&addr, prefix, naddr);
+                return EOK;
+        }
+
+        return EINVAL;
+}
+
+static int inet_addr_format_v4(addr32_t addr, char **bufp)
+{
+        int rc;
+
+        rc = asprintf(bufp, "%u.%u.%u.%u", (addr >> 24) & 0xff,
+            (addr >> 16) & 0xff, (addr >> 8) & 0xff, addr & 0xff);
+        if (rc < 0)
+                return ENOMEM;
+
+        return EOK;
+}
+
+static int inet_addr_format_v6(const addr128_t addr, char **bufp)
+{
+        *bufp = (char *) malloc(INET6_ADDRSTRLEN);
+        if (*bufp == NULL)
+                return ENOMEM;
+
+        /* Find the longest zero subsequence */
+
+        uint16_t zeroes[8];
+        uint16_t bioctets[8];
+
+        for (size_t i = 8; i > 0; i--) {
+                size_t j = i - 1;
+
+                bioctets[j] = (addr[j << 1] << 8) | addr[(j << 1) + 1];
+
+                if (bioctets[j] == 0) {
+                        zeroes[j] = 1;
+                        if (j < 7)
+                                zeroes[j] += zeroes[j + 1];
+                } else
+                        zeroes[j] = 0;
+        }
+
+        size_t wildcard_pos = (size_t) -1;
+        size_t wildcard_size = 0;
+
+        for (size_t i = 0; i < 8; i++) {
+                if (zeroes[i] > wildcard_size) {
+                        wildcard_pos = i;
+                        wildcard_size = zeroes[i];
+                }
+        }
+
+        char *cur = *bufp;
+        size_t rest = INET6_ADDRSTRLEN;
+        bool tail_zero = false;
+        int ret;
+
+        for (size_t i = 0; i < 8; i++) {
+                if ((i == wildcard_pos) && (wildcard_size > 1)) {
+                        ret = snprintf(cur, rest, ":");
+                        i += wildcard_size - 1;
+                        tail_zero = true;
+                } else if (i == 0) {
+                        ret = snprintf(cur, rest, "%" PRIx16, bioctets[i]);
+                        tail_zero = false;
+                } else {
+                        ret = snprintf(cur, rest, ":%" PRIx16, bioctets[i]);
+                        tail_zero = false;
+                }
+
+                if (ret < 0)
                         return EINVAL;
-                
-                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;
-                
-                memcpy(naddr->addr6, buf, 16);
-                naddr->prefix = prefix;
-                
-                break;
-        default:
-                return ENOTSUP;
-        }
-        
+
+                cur += ret;
+                rest -= ret;
+        }
+
+        if (tail_zero)
+                (void) snprintf(cur, rest, ":");
+
         return EOK;
 }
@@ -446 +567 @@
 int inet_addr_format(const inet_addr_t *addr, char **bufp)
 {
-        int rc = 0;
-        
+        int rc;
+
+        rc = ENOTSUP;
+
         switch (addr->version) {
         case ip_any:
                 rc = asprintf(bufp, "none");
+                if (rc < 0)
+                        return ENOMEM;
+                rc = EOK;
                 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);
+                rc = inet_addr_format_v4(addr->addr, bufp);
                 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;
+                rc = inet_addr_format_v6(addr->addr6, bufp);
+                break;
+        }
+
+        return rc;
 }
 
@@ -485 +601 @@
 int inet_naddr_format(const inet_naddr_t *naddr, char **bufp)
 {
-        int rc = 0;
-        char prefix[INET_PREFIXSTRSIZE];
-        
+        int rc;
+        char *astr;
+
+        rc = ENOTSUP;
+
         switch (naddr->version) {
         case ip_any:
                 rc = asprintf(bufp, "none");
+                if (rc < 0)
+                        return ENOMEM;
+                rc = EOK;
                 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)
+                rc = inet_addr_format_v4(naddr->addr, &astr);
+                if (rc != EOK)
                         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);
+
+                rc = asprintf(bufp, "%s/%" PRIu8, astr, naddr->prefix);
                 if (rc < 0) {
-                        free(*bufp);
+                        free(astr);
                         return ENOMEM;
                 }
-                
-                str_append(*bufp, INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE, prefix);
-                
-                break;
-        default:
-                return ENOTSUP;
-        }
-        
-        if (rc < 0)
-                return ENOMEM;
-        
-        return EOK;
+
+                rc = EOK;
+                break;
+        case ip_v6:
+                rc = inet_addr_format_v6(naddr->addr6, &astr);
+                if (rc != EOK)
+                        return ENOMEM;
+
+                rc = asprintf(bufp, "%s/%" PRIu8, astr, naddr->prefix);
+                if (rc < 0) {
+                        free(astr);
+                        return ENOMEM;
+                }
+
+                rc = EOK;
+                break;
+        }
+
+        return rc;
 }
 
@@ -586 +700 @@
 }
 
-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)
 {
@@ -605 +713 @@
 }
 
-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;
-}
-
 /** @}
  */