subnets 1.0.0pre

data/ext/subnets/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+have_header('ctype.h')
+have_header('stdint.h')
+
+create_makefile('subnets')

data/ext/subnets/ipaddr.c

@@ -0,0 +1,402 @@
+#include <ctype.h>              /* isdigit, isxdigit */
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <unistd.h>
+
+#include "ipaddr.h"
+
+ip4_t
+mk_mask4(int prefixlen) {
+  if (prefixlen==0) return 0;
+
+  int shift = 32 - prefixlen;
+  return (~((ip4_t) 0) >> shift) << shift;
+}
+
+ip6_t
+mk_mask6(int prefixlen) {
+  ip6_t mask;
+  uint16_t ones = ~((uint16_t) 0);
+
+  int pivot = prefixlen / 16;
+  int shift = 16 - (prefixlen % 16);
+
+  for (int i=0; i<pivot && i<8; i++) {
+    mask.x[i] = ones;
+  }
+  if (pivot<8) {
+    mask.x[pivot] = (ones >> shift) << shift;
+  }
+  for (int i = pivot+1; i<8; i++) {
+    mask.x[i] = 0;
+  }
+
+  return mask;
+}
+
+int
+net4_include_p(net4_t net, ip4_t a) {
+  return ((net.address & net.mask) == (a & net.mask));
+}
+
+int
+net6_include_p(net6_t net, ip6_t a) {
+  for (int i=0; i<8; i++) {
+    if ((net.address.x[i] & net.mask.x[i]) != (a.x[i] & net.mask.x[i])) return 0;
+  }
+  return !0;
+}
+
+int
+net4_include_net4_p(net4_t net, net4_t other) {
+  return net.prefixlen <= other.prefixlen && net4_include_p(net, other.address);
+}
+
+int
+net6_include_net6_p(net6_t net, net6_t other) {
+  return net.prefixlen <= other.prefixlen && net6_include_p(net, other.address);
+}
+
+net4_t
+net4_network(net4_t net) {
+  net.address = net.address & net.mask;
+  return net;
+}
+
+int
+ip4_snprint(ip4_t ip, char *str, size_t size) {
+  return snprintf(str, size, "%u.%u.%u.%u",
+                  (ip >> 24) & 0xff,
+                  (ip >> 16) & 0xff,
+                  (ip >> 8) & 0xff,
+                  (ip >> 0) & 0xff);
+}
+
+int
+net4_snprint(net4_t net, char *str, size_t size) {
+  return snprintf(str, size, "%u.%u.%u.%u/%d",
+                  (net.address >> 24) & 0xff,
+                  (net.address >> 16) & 0xff,
+                  (net.address >> 8) & 0xff,
+                  (net.address >> 0) & 0xff,
+                  net.prefixlen);
+}
+
+int
+ip6_snprint(ip6_t ip, char *str, size_t size) {
+  /* find first longest string of zeroes */
+  int longzerostart = -1;
+  int longzeroend = -1;
+
+  int currzerostart = -1;
+  int currzeroend = -1;
+
+  for (int i = 0; i < 8; i++) {
+    if (0 == ip.x[i]) {
+      currzeroend = i+1;
+      if (currzerostart < 0) {
+        currzerostart = i;
+      }
+      if ((currzeroend - currzerostart) > (longzeroend - longzerostart)) {
+        longzerostart = currzerostart;
+        longzeroend = currzeroend;
+      }
+    } else {
+      if (currzerostart >= 0) {
+        currzerostart = -1;
+      }
+    }
+  }
+
+  if (longzeroend - longzerostart <= 1) {
+    return snprintf(str, size, "%x:%x:%x:%x:%x:%x:%x:%x",
+                    ip.x[0],
+                    ip.x[1],
+                    ip.x[2],
+                    ip.x[3],
+                    ip.x[4],
+                    ip.x[5],
+                    ip.x[6],
+                    ip.x[7]);
+  } else {
+    int total = 0;
+    int n;
+
+    /* print first before zeros */
+    for (int i = 0; i < 1 && i < longzerostart; i++) {
+      n = snprintf(str+total, size-total, "%x", ip.x[i]);
+      if (n < 0) { return n; }
+      total += n;
+    }
+
+    /* print rest before zeros with leading colon */
+    for (int i = 1; i < longzerostart; i++) {
+      n = snprintf(str+total, size-total, ":");
+      if (n < 0) { return n; }
+      total += n;
+      n = snprintf(str+total, size-total, "%x", ip.x[i]);
+      if (n < 0) { return n; }
+      total += n;
+    }
+
+    /* print double colon */
+    n = snprintf(str+total, size-total, "::");
+    if (n < 0) { return n; }
+    total += n;
+
+    /* print first after zeros */
+    for (int i = longzeroend; i < 8 && i < longzeroend+1; i++) {
+      n = snprintf(str+total, size-total, "%x", ip.x[i]);
+      if (n < 0) { return n; }
+      total += n;
+    }
+
+    /* print rest after zeros with leading colon */
+    for (int i = longzeroend + 1; i < 8; i++) {
+      n = snprintf(str+total, size-total, ":");
+      if (n < 0) { return n; }
+      total += n;
+
+      n = snprintf(str+total, size-total, "%x", ip.x[i]);
+      if (n < 0) { return n; }
+      total += n;
+    }
+
+    return total;
+  }
+}
+
+int
+net6_snprint(net6_t net, char *str, size_t size) {
+  int n0, n1;
+  n0 = ip6_snprint(net.address, str, size);
+  if (n0 < 0) {
+    return n0;
+  }
+
+  n1 = snprintf(str+n0, size-n0, "/%d", net.prefixlen);
+  if (n1 < 0) {
+    return n1;
+  }
+
+  return n0 + n1;
+}
+
+int
+hexvalue(unsigned int c) {
+  if (c-'0'<10) return c-'0';
+  if (c-'a'<6) return c-'a'+10;
+  if (c-'A'<6) return c-'A'+10;
+  return -1;
+}
+
+/*
+ * read_ip4 is adapted from musl-libc inet_pton
+ * https://git.musl-libc.org/cgit/musl/tree/src/network/inet_pton.c?id=fc13acc3dcb5b1f215c007f583a63551f6a71363
+ *
+ * Copyright © 2005-2014 Rich Felker, et al.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */
+/**
+ * Read an Ip4 address from s.
+ *
+ * @return the number of characters consumed
+ */
+size_t
+read_ip4(const char *s, ip4_t *a) {
+  size_t pos = 0;
+
+  *a = 0;
+
+  for (int i = 0; i < 4; i++) {
+    int v, j;
+    for (v=j=0; j < 3 && isdigit(s[pos+j]); j++) {
+      v = 10*v + s[pos+j]-'0';
+    }
+    if (j==0 || (j>1 && s[pos]=='0') || v>255) return 0;
+    *a |= (v & 0xff) << (3-i)*8;
+    pos += j;
+    if (i == 3) return pos;
+    if (s[pos++] != '.') return 0;
+  }
+
+  return 0;
+}
+
+size_t
+read_hextet(const char *s, uint16_t *v) {
+  int i;
+  for (i=0; i<4 && isxdigit(s[i]); i++) {
+    *v = 0x10*(*v) + hexvalue(s[i]);
+  }
+  if (i>1 && s[0]=='0') return 0;
+  return i;
+}
+
+size_t
+read_ip6(const char *s, ip6_t *a) {
+  uint16_t hextets[8] = { 0, 0, 0, 0, 0, 0, 0, 0, };
+  size_t n;
+  int i = 0;
+  size_t pos = 0;
+  int brk = 8;
+
+  /* 
+   * read optional leading hextet followed by zero or more
+   * colon-hextet pairs, zero or one lone colon (the second of a
+   * double-colon), zero or more colon-hextet pairs.
+   */
+
+  n = read_hextet(s+pos, &hextets[i]);
+  if (n) {
+    //printf("read hextet %d: %x\n", i, hextets[i]);
+    pos+=n;
+    i++;
+  }
+
+  for (; i < 8;) {
+    if (s[pos] != ':') break;
+    pos++;
+
+    if (brk==8 && s[pos] == ':') {
+      //printf("see break at pos=%d, brk=%d\n", pos, i);
+      pos++;
+      brk = i;
+      if (!isxdigit(s[pos])) break;
+    }
+    else if (i==0) {            /* can't lead with single-colon */
+      return 0;
+    }
+
+    ip4_t ip4;
+    if ((i==6 || (brk<8 && i<4)) && (n = read_ip4(s+pos, &ip4))) {
+      pos += n;
+      hextets[i] = (ip4 >> 16) & 0xffff;
+      hextets[i+1] = (ip4 >> 0) & 0xffff;
+      i+=2;
+      break;
+    }
+
+    n = read_hextet(s+pos, &hextets[i]);
+    if (n) {
+      //printf("read hextet %d: %x\n", i, hextets[i]);
+      pos+=n;
+      i++;
+    }
+    else {
+      //printf("error 'cause read %c\n", s[pos]);
+      return 0;
+    }
+  }
+
+  if (brk==8 && i<8) return 0;
+  if (brk<8 && i==8) return 0;
+
+  for (int k = 0; k < 8; k++) {
+    //printf("brk=%d i=%d hextets[%d]=%x\n", brk, i, k, hextets[k]);
+  }
+
+  /* TODO move down hextets after the break */
+  //printf("before\n");
+  for (int j = 0; j < brk; j++) {
+    a->x[j] = hextets[j];
+  }
+  //printf("brk\n");
+  for (int j = 0; j < (8-i); j++) {
+    a->x[j+brk] = 0;
+  }
+  //printf("after\n");
+  for (int j = 0; j < (i-brk); j++) {
+    //printf(" (from hextets[%d])\n", j+brk);
+    a->x[j+(8-i)+brk] = hextets[j+brk];
+  }
+
+  return pos;
+}
+
+size_t
+read_net4(const char *s, net4_t *net) {
+  int i, v=0;
+  size_t pos = read_ip4(s, &net->address);
+  if (!pos) return 0;
+
+  if (!(s[pos++] == '/')) return 0;
+  for (i = 0; i < 2 && isdigit(s[pos+i]); i++) {
+    v = v*10 + s[pos+i]-'0';
+  }
+  if (i==0 || (i>1 && s[pos]=='0') || v>32) return 0;
+  net->prefixlen = v;
+  net->mask = mk_mask4(net->prefixlen);
+  return pos+i;
+}
+
+size_t
+read_ip4_strict(const char *s, ip4_t *ip) {
+  size_t n = read_ip4(s, ip);
+  if (!n || s[n] != 0) return 0;
+  return n;
+}
+
+size_t
+read_net4_strict(const char *s, net4_t *net) {
+  size_t n = read_net4(s, net);
+  if (!n || s[n] != 0) return 0;
+  return n;
+}
+
+size_t
+read_ip6_strict(const char *s, ip6_t *ip) {
+  size_t n = read_ip6(s, ip);
+  if (!n || s[n] != 0) return 0;
+  return n;
+}
+
+size_t
+read_net6_strict(const char *s, net6_t *net) {
+  size_t n = read_net6(s, net);
+  if (!n || s[n] != 0) return 0;
+  return n;
+}
+
+size_t
+read_net6(const char *s, net6_t *net) {
+  size_t pos;
+
+  pos = read_ip6(s, &net->address);
+  if (!pos) return 0;
+
+  int i, v = 0;
+  if (s[pos++] != '/') return 0;
+  for (i = 0; i < 3 && isdigit(s[pos+i]); i++) {
+    v = v*10 + s[pos+i]-'0';
+  }
+  if (i==0 || (i>1 && s[pos]=='0') || v>128) return 0;
+  net->prefixlen = v;
+  net->mask = mk_mask6(net->prefixlen);
+  return pos+i;
+}

data/ext/subnets/ipaddr.h

@@ -0,0 +1,105 @@
+#ifndef __IPADDR_H__
+#define __IPADDR_H__
+
+#include <ctype.h>              /* isdigit, isxdigit */
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <unistd.h>
+
+typedef uint32_t ip4_t;
+
+typedef struct {
+  int prefixlen;
+  ip4_t address;
+  ip4_t mask;
+} net4_t;
+
+typedef struct {
+  uint16_t x[8];
+} ip6_t;
+
+typedef struct {
+  int prefixlen;
+  ip6_t address;
+  ip6_t mask;
+} net6_t;
+
+/**
+ * Make an IPv4 mask of the given prefixlen in the range [0,32].
+ */
+ip4_t mk_mask4(int prefixlen);
+
+/**
+ * Make an IPv6 mask of the given prefixlen in the range [0,128].
+ */
+ip6_t mk_mask6(int prefixlen);
+
+/**
+ * Test if this network includes the given ip.
+ */
+int net4_include_p(net4_t, ip4_t);
+int net6_include_p(net6_t, ip6_t);
+
+/**
+ * Test if this network includes the given network, which must have a
+ * prefexlen greater than or equal to that of this network and a
+ * network address that is included within this network.
+ */
+int net4_include_net4_p(net4_t, net4_t);
+int net6_include_net6_p(net6_t, net6_t);
+
+/**
+ * Zero-out the host portion of this network by applying the netmask,
+ * and return that network.
+ */
+net4_t net4_network(net4_t);
+net6_t net6_network(net6_t);
+
+/**
+ * Write a string representation of this network to the given string,
+ * according to the rules of snprintf().
+ */
+int net4_snprint(net4_t, char *, size_t);
+int net6_snprint(net6_t, char *, size_t);
+
+/**
+ * Write a string representation of this ip to the given string,
+ * according to the rules of snprintf().
+ */
+int ip4_snprint(ip4_t, char *, size_t);
+int ip6_snprint(ip6_t, char *, size_t);
+
+/**
+ * Read an IP from the string, returning the number of bytes read, or
+ * zero on parse error.
+ */
+size_t read_ip4(const char *, ip4_t *);
+size_t read_ip6(const char *, ip6_t *);
+
+/**
+ * Read a network from the string, returning the number of bytes read,
+ * or zero on parse error.
+ */
+size_t read_net4(const char *, net4_t *);
+size_t read_net6(const char *, net6_t *);
+
+/**
+ * Like read_ip*, but it is an error if the IP is not followed by a
+ * null byte.
+ */
+size_t read_ip4_strict(const char *, ip4_t *);
+size_t read_ip6_strict(const char *, ip6_t *);
+
+/**
+ * Like read_net*, but it is an error if the network is not followed
+ * by a null byte.
+ */
+size_t read_net4_strict(const char *, net4_t *);
+size_t read_net6_strict(const char *, net6_t *);
+
+#endif                          /* __IPADDR_H__ */