rel_1.6.0 init

Living_SDK/device/sal/ip4_addr.c

@@ -0,0 +1,222 @@
+/*
+ * Copyright (C) 2015-2017 Alibaba Group Holding Limited
+ */
+
+#include "internal/sal_sockets_internal.h"
+
+/* Here for now until needed in other places in lwIP */
+#ifndef isprint
+#define in_range(c, lo, up)  ((u8_t)c >= lo && (u8_t)c <= up)
+#define isprint(c)           in_range(c, 0x20, 0x7f)
+#define isdigit(c)           in_range(c, '0', '9')
+#define isxdigit(c)          (isdigit(c) || in_range(c, 'a', 'f') || in_range(c, 'A', 'F'))
+#define islower(c)           in_range(c, 'a', 'z')
+#define isspace(c)           (c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\t' || c == '\v')
+#endif
+
+/**
+ * Check whether "cp" is a valid ascii representation
+ * of an Internet address and convert to a binary address.
+ * Returns 1 if the address is valid, 0 if not.
+ * This replaces inet_addr, the return value from which
+ * cannot distinguish between failure and a local broadcast address.
+ *
+ * @param cp IP address in ascii representation (e.g. "127.0.0.1")
+ * @param addr pointer to which to save the ip address in network order
+ * @return 1 if cp could be converted to addr, 0 on failure
+ */
+int
+ip4addr_aton(const char *cp, ip4_addr_t *addr)
+{
+    u32_t val;
+    u8_t base;
+    char c;
+    u32_t parts[4];
+    u32_t *pp = parts;
+
+    c = *cp;
+    for (;;) {
+        /*
+         * Collect number up to ``.''.
+         * Values are specified as for C:
+         * 0x=hex, 0=octal, 1-9=decimal.
+         */
+        if (!isdigit(c)) {
+            return 0;
+        }
+        val = 0;
+        base = 10;
+        if (c == '0') {
+            c = *++cp;
+            if (c == 'x' || c == 'X') {
+                base = 16;
+                c = *++cp;
+            } else {
+                base = 8;
+            }
+        }
+        for (;;) {
+            if (isdigit(c)) {
+                val = (val * base) + (int)(c - '0');
+                c = *++cp;
+            } else if (base == 16 && isxdigit(c)) {
+                val = (val << 4) | (int)(c + 10 - (islower(c) ? 'a' : 'A'));
+                c = *++cp;
+            } else {
+                break;
+            }
+        }
+        if (c == '.') {
+            /*
+             * Internet format:
+             *  a.b.c.d
+             *  a.b.c   (with c treated as 16 bits)
+             *  a.b (with b treated as 24 bits)
+             */
+            if (pp >= parts + 3) {
+                return 0;
+            }
+            *pp++ = val;
+            c = *++cp;
+        } else {
+            break;
+        }
+    }
+    /*
+     * Check for trailing characters.
+     */
+    if (c != '\0' && !isspace(c)) {
+        return 0;
+    }
+    /*
+     * Concoct the address according to
+     * the number of parts specified.
+     */
+    switch (pp - parts + 1) {
+
+        case 0:
+            return 0;       /* initial nondigit */
+
+        case 1:             /* a -- 32 bits */
+            break;
+
+        case 2:             /* a.b -- 8.24 bits */
+            if (val > 0xffffffUL) {
+                return 0;
+            }
+            if (parts[0] > 0xff) {
+                return 0;
+            }
+            val |= parts[0] << 24;
+            break;
+
+        case 3:             /* a.b.c -- 8.8.16 bits */
+            if (val > 0xffff) {
+                return 0;
+            }
+            if ((parts[0] > 0xff) || (parts[1] > 0xff)) {
+                return 0;
+            }
+            val |= (parts[0] << 24) | (parts[1] << 16);
+            break;
+
+        case 4:             /* a.b.c.d -- 8.8.8.8 bits */
+            if (val > 0xff) {
+                return 0;
+            }
+            if ((parts[0] > 0xff) || (parts[1] > 0xff) || (parts[2] > 0xff)) {
+                return 0;
+            }
+            val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
+            break;
+        default:
+            SAL_ASSERT("unhandled", 0);
+            break;
+    }
+    if (addr) {
+        ip4_addr_set_u32(addr, sal_htonl(val));
+    }
+    return 1;
+}
+
+/**
+ * Same as ipaddr_ntoa, but reentrant since a user-supplied buffer is used.
+ *
+ * @param addr ip address in network order to convert
+ * @param buf target buffer where the string is stored
+ * @param buflen length of buf
+ * @return either pointer to buf which now holds the ASCII
+ *         representation of addr or NULL if buf was too small
+ */
+char *
+ip4addr_ntoa_r(const ip4_addr_t *addr, char *buf, int buflen)
+{
+    u32_t s_addr;
+    char inv[3];
+    char *rp;
+    u8_t *ap;
+    u8_t rem;
+    u8_t n;
+    u8_t i;
+    int len = 0;
+
+    s_addr = ip4_addr_get_u32(addr);
+
+    rp = buf;
+    ap = (u8_t *)&s_addr;
+    for (n = 0; n < 4; n++) {
+        i = 0;
+        do {
+            rem = *ap % (u8_t)10;
+            *ap /= (u8_t)10;
+            inv[i++] = '0' + rem;
+        } while (*ap);
+        while (i--) {
+            if (len++ >= buflen) {
+                return NULL;
+            }
+            *rp++ = inv[i];
+        }
+        if (len++ >= buflen) {
+            return NULL;
+        }
+        *rp++ = '.';
+        ap++;
+    }
+    *--rp = 0;
+    return buf;
+}
+
+/**
+ * Convert numeric IP address into decimal dotted ASCII representation.
+ * returns ptr to static buffer; not reentrant!
+ *
+ * @param addr ip address in network order to convert
+ * @return pointer to a global static (!) buffer that holds the ASCII
+ *         representation of addr
+ */
+char *
+ip4addr_ntoa(const ip4_addr_t *addr)
+{
+    static char str[SAL_SOCKET_IP4_ADDR_LEN];
+    return ip4addr_ntoa_r(addr, str, SAL_SOCKET_IP4_ADDR_LEN);
+}
+
+/**
+ * Ascii internet address interpretation routine.
+ * The value returned is in network order.
+ *
+ * @param cp IP address in ascii representation (e.g. "127.0.0.1")
+ * @return ip address in network order
+ */
+in_addr_t
+ipaddr_addr(const char *cp)
+{
+    ip4_addr_t val;
+
+    if (ip4addr_aton(cp, &val)) {
+        return ip4_addr_get_u32(&val);
+    }
+    return (IPADDR_NONE);
+}
+