pth: Use barriers in pthread tests
[akaros.git] / user / iplib / parseip.c
old mode 100755 (executable)
new mode 100644 (file)
index cb0db85..973cd0d
@@ -1,4 +1,4 @@
-/* 
+/*
  * This file is part of the UCB release of Plan 9. It is subject to the license
  * terms in the LICENSE file found in the top-level directory of this
  * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
@@ -8,43 +8,56 @@
  */
 #include <stdlib.h>
 
+#include <iplib/iplib.h>
+#include <parlib/parlib.h>
+#include <signal.h>
 #include <stdio.h>
-#include <parlib.h>
 #include <unistd.h>
-#include <signal.h>
-#include <iplib.h>
 
-static int isascii(int c) {return ((c >=0) && (c <= 128));}
-static int isalnum(int c) {return ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||(c >= '0' && c <= '9'));}
-static int isdigit(int c) {return ((c >= '0' && c <= '9'));}
-static int isxdigit(int c) {return ((c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') ||(c >= '0' && c <= '9'));}
+static int isascii(int c)
+{
+       return ((c >= 0) && (c <= 128));
+}
+static int isalnum(int c)
+{
+       return ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
+               (c >= '0' && c <= '9'));
+}
+static int isdigit(int c)
+{
+       return ((c >= '0' && c <= '9'));
+}
+static int isxdigit(int c)
+{
+       return ((c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') ||
+               (c >= '0' && c <= '9'));
+}
 
-char*
-v4parseip(uint8_t *to, char *from)
+char *v4parseip(uint8_t *to, char *from)
 {
        int i;
        char *p;
 
        p = from;
-       for(i = 0; i < 4 && *p; i++){
+       for (i = 0; i < 4 && *p; i++) {
                to[i] = strtoul(p, &p, 0);
-               if(*p == '.')
+               if (*p == '.')
                        p++;
        }
-       switch(CLASS(to)){
-       case 0: /* class A - 1 uchar net */
+       switch (CLASS(to)) {
+       case 0: /* class A - 1 uchar net */
        case 1:
-               if(i == 3){
+               if (i == 3) {
                        to[3] = to[2];
                        to[2] = to[1];
                        to[1] = 0;
-               } else if (i == 2){
+               } else if (i == 2) {
                        to[3] = to[1];
                        to[1] = 0;
                }
                break;
-       case 2: /* class B - 2 uchar net */
-               if(i == 3){
+       case 2: /* class B - 2 uchar net */
+               if (i == 3) {
                        to[3] = to[2];
                        to[2] = 0;
                }
@@ -53,18 +66,16 @@ v4parseip(uint8_t *to, char *from)
        return p;
 }
 
-static int
-ipcharok(int c)
+static int ipcharok(int c)
 {
        return c == '.' || c == ':' || isascii(c) && isxdigit(c);
 }
 
-static int
-delimchar(int c)
+static int delimchar(int c)
 {
-       if(c == '\0')
+       if (c == '\0')
                return 1;
-       if(c == '.' || c == ':' || isascii(c) && isalnum(c))
+       if (c == '.' || c == ':' || isascii(c) && isalnum(c))
                return 0;
        return 1;
 }
@@ -77,8 +88,7 @@ delimchar(int c)
  * some callers don't check the return value for errors, so
  * set `to' to something distinctive in the case of a parse error.
  */
-int64_t
-parseip(uint8_t *to, char *from)
+int64_t parseip(uint8_t *to, char *from)
 {
        int i, elipsis = 0, v4 = 1;
        uint32_t x;
@@ -86,43 +96,43 @@ parseip(uint8_t *to, char *from)
 
        memset(to, 0, IPaddrlen);
        p = from;
-       for(i = 0; i < IPaddrlen && ipcharok(*p); i+=2){
+       for (i = 0; i < IPaddrlen && ipcharok(*p); i += 2) {
                op = p;
                x = strtoul(p, &p, 16);
-               if(*p == '.' || (*p == 0 && i == 0)){   /* ends with v4? */
-                       p = v4parseip(to+i, op);
+               if (*p == '.' || (*p == 0 && i == 0)) { /* ends with v4? */
+                       p = v4parseip(to + i, op);
                        i += 4;
                        break;
                }
                /* v6: at most 4 hex digits, followed by colon or delim */
-               if(x != (uint16_t)x || *p != ':' && !delimchar(*p)) {
+               if (x != (uint16_t)x || *p != ':' && !delimchar(*p)) {
                        memset(to, 0, IPaddrlen);
-                       return -1;                      /* parse error */
+                       return -1; /* parse error */
                }
-               to[i] = x>>8;
-               to[i+1] = x;
-               if(*p == ':'){
+               to[i] = x >> 8;
+               to[i + 1] = x;
+               if (*p == ':') {
                        v4 = 0;
-                       if(*++p == ':'){        /* :: is elided zero short(s) */
+                       if (*++p == ':') { /* :: is elided zero short(s) */
                                if (elipsis) {
                                        memset(to, 0, IPaddrlen);
-                                       return -1;      /* second :: */
+                                       return -1; /* second :: */
                                }
-                               elipsis = i+2;
+                               elipsis = i + 2;
                                p++;
                        }
-               } else if (p == op)             /* strtoul made no progress? */
+               } else if (p == op) /* strtoul made no progress? */
                        break;
        }
        if (p == from || !delimchar(*p)) {
                memset(to, 0, IPaddrlen);
-               return -1;                              /* parse error */
+               return -1; /* parse error */
        }
-       if(i < IPaddrlen){
-               memmove(&to[elipsis+IPaddrlen-i], &to[elipsis], i-elipsis);
-               memset(&to[elipsis], 0, IPaddrlen-i);
+       if (i < IPaddrlen) {
+               memmove(&to[elipsis + IPaddrlen - i], &to[elipsis], i - elipsis);
+               memset(&to[elipsis], 0, IPaddrlen - i);
        }
-       if(v4){
+       if (v4) {
                to[10] = to[11] = 0xff;
                return nhgetl(to + IPv4off);
        } else
@@ -133,40 +143,39 @@ parseip(uint8_t *to, char *from)
  *  hack to allow ip v4 masks to be entered in the old
  *  style
  */
-int64_t
-parseipmask(uint8_t *to, char *from)
+int64_t parseipmask(uint8_t *to, char *from)
 {
        int i, w;
        int64_t x;
        uint8_t *p;
 
-       if(*from == '/'){
+       if (*from == '/') {
                /* as a number of prefix bits */
-               i = atoi(from+1);
-               if(i < 0)
+               i = atoi(from + 1);
+               if (i < 0)
                        i = 0;
-               if(i > 128)
+               if (i > 128)
                        i = 128;
                w = i;
                memset(to, 0, IPaddrlen);
-               for(p = to; i >= 8; i -= 8)
+               for (p = to; i >= 8; i -= 8)
                        *p++ = 0xff;
-               if(i > 0)
-                       *p = ~((1<<(8-i))-1);
-               x = nhgetl(to+IPv4off);
+               if (i > 0)
+                       *p = ~((1 << (8 - i)) - 1);
+               x = nhgetl(to + IPv4off);
                /*
                 * identify as ipv6 if the mask is inexpressible as a v4 mask
                 * (because it has too few mask bits).  Arguably, we could
                 * always return 6 here.
                 */
-               if (w < 8*(IPaddrlen-IPv4addrlen))
+               if (w < 8 * (IPaddrlen - IPv4addrlen))
                        return 6;
        } else {
                /* as a straight v4 bit mask */
                x = parseip(to, from);
                if (x != -1)
                        x = (uint32_t)nhgetl(to + IPv4off);
-               if(memcmp(to, v4prefix, IPv4off) == 0)
+               if (memcmp(to, v4prefix, IPv4off) == 0)
                        memset(to, 0xff, IPv4off);
        }
        return x;
@@ -175,8 +184,7 @@ parseipmask(uint8_t *to, char *from)
 /*
  *  parse a v4 ip address/mask in cidr format
  */
-char*
-v4parsecidr(uint8_t *addr, uint8_t *mask, char *from)
+char *v4parsecidr(uint8_t *addr, uint8_t *mask, char *from)
 {
        int i;
        char *p;
@@ -184,17 +192,19 @@ v4parsecidr(uint8_t *addr, uint8_t *mask, char *from)
 
        p = v4parseip(addr, from);
 
-       if(*p == '/'){
+       if (*p == '/') {
                /* as a number of prefix bits */
-               i = strtoul(p+1, &p, 0);
-               if(i > 32)
-                       i = 32;
+               i = strtoul(p + 1, &p, 0);
+               /* We might have been passed a v6 mask - the signal for that will be
+                * having more than 32 bits. */
+               if (i >= 32)
+                       i -= 128 - 32;
                memset(mask, 0, IPv4addrlen);
-               for(a = mask; i >= 8; i -= 8)
+               for (a = mask; i >= 8; i -= 8)
                        *a++ = 0xff;
-               if(i > 0)
-                       *a = ~((1<<(8-i))-1);
-       } else 
+               if (i > 0)
+                       *a = ~((1 << (8 - i)) - 1);
+       } else
                memcpy(mask, defmask(addr), IPv4addrlen);
        return p;
 }