Initial transfer of provider code

3 files changed, 169 insertions, 0 deletions

diff --git a/vendor/github.com/apparentlymart/go-cidr/LICENSE b/vendor/github.com/apparentlymart/go-cidr/LICENSE
new file mode 100644
index 0000000..2125378
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-cidr/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2015 Martin Atkins
+
+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.
diff --git a/vendor/github.com/apparentlymart/go-cidr/cidr/cidr.go b/vendor/github.com/apparentlymart/go-cidr/cidr/cidr.go
new file mode 100644
index 0000000..a31cdec
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-cidr/cidr/cidr.go
@@ -0,0 +1,112 @@
+// Package cidr is a collection of assorted utilities for computing
+// network and host addresses within network ranges.
+//
+// It expects a CIDR-type address structure where addresses are divided into
+// some number of prefix bits representing the network and then the remaining
+// suffix bits represent the host.
+//
+// For example, it can help to calculate addresses for sub-networks of a
+// parent network, or to calculate host addresses within a particular prefix.
+//
+// At present this package is prioritizing simplicity of implementation and
+// de-prioritizing speed and memory usage. Thus caution is advised before
+// using this package in performance-critical applications or hot codepaths.
+// Patches to improve the speed and memory usage may be accepted as long as
+// they do not result in a significant increase in code complexity.
+package cidr
+
+import (
+        "fmt"
+        "math/big"
+        "net"
+)
+
+// Subnet takes a parent CIDR range and creates a subnet within it
+// with the given number of additional prefix bits and the given
+// network number.
+//
+// For example, 10.3.0.0/16, extended by 8 bits, with a network number
+// of 5, becomes 10.3.5.0/24 .
+func Subnet(base *net.IPNet, newBits int, num int) (*net.IPNet, error) {
+        ip := base.IP
+        mask := base.Mask
+
+        parentLen, addrLen := mask.Size()
+        newPrefixLen := parentLen + newBits
+
+        if newPrefixLen > addrLen {
+                return nil, fmt.Errorf("insufficient address space to extend prefix of %d by %d", parentLen, newBits)
+        }
+
+        maxNetNum := uint64(1<<uint64(newBits)) - 1
+        if uint64(num) > maxNetNum {
+                return nil, fmt.Errorf("prefix extension of %d does not accommodate a subnet numbered %d", newBits, num)
+        }
+
+        return &net.IPNet{
+                IP:   insertNumIntoIP(ip, num, newPrefixLen),
+                Mask: net.CIDRMask(newPrefixLen, addrLen),
+        }, nil
+}
+
+// Host takes a parent CIDR range and turns it into a host IP address with
+// the given host number.
+//
+// For example, 10.3.0.0/16 with a host number of 2 gives 10.3.0.2.
+func Host(base *net.IPNet, num int) (net.IP, error) {
+        ip := base.IP
+        mask := base.Mask
+
+        parentLen, addrLen := mask.Size()
+        hostLen := addrLen - parentLen
+
+        maxHostNum := uint64(1<<uint64(hostLen)) - 1
+
+        numUint64 := uint64(num)
+        if num < 0 {
+                numUint64 = uint64(-num) - 1
+                num = int(maxHostNum - numUint64)
+        }
+
+        if numUint64 > maxHostNum {
+                return nil, fmt.Errorf("prefix of %d does not accommodate a host numbered %d", parentLen, num)
+        }
+
+        return insertNumIntoIP(ip, num, 32), nil
+}
+
+// AddressRange returns the first and last addresses in the given CIDR range.
+func AddressRange(network *net.IPNet) (net.IP, net.IP) {
+        // the first IP is easy
+        firstIP := network.IP
+
+        // the last IP is the network address OR NOT the mask address
+        prefixLen, bits := network.Mask.Size()
+        if prefixLen == bits {
+                // Easy!
+                // But make sure that our two slices are distinct, since they
+                // would be in all other cases.
+                lastIP := make([]byte, len(firstIP))
+                copy(lastIP, firstIP)
+                return firstIP, lastIP
+        }
+
+        firstIPInt, bits := ipToInt(firstIP)
+        hostLen := uint(bits) - uint(prefixLen)
+        lastIPInt := big.NewInt(1)
+        lastIPInt.Lsh(lastIPInt, hostLen)
+        lastIPInt.Sub(lastIPInt, big.NewInt(1))
+        lastIPInt.Or(lastIPInt, firstIPInt)
+
+        return firstIP, intToIP(lastIPInt, bits)
+}
+
+// AddressCount returns the number of distinct host addresses within the given
+// CIDR range.
+//
+// Since the result is a uint64, this function returns meaningful information
+// only for IPv4 ranges and IPv6 ranges with a prefix size of at least 65.
+func AddressCount(network *net.IPNet) uint64 {
+        prefixLen, bits := network.Mask.Size()
+        return 1 << (uint64(bits) - uint64(prefixLen))
+}
diff --git a/vendor/github.com/apparentlymart/go-cidr/cidr/wrangling.go b/vendor/github.com/apparentlymart/go-cidr/cidr/wrangling.go
new file mode 100644
index 0000000..861a5f6
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-cidr/cidr/wrangling.go
@@ -0,0 +1,38 @@
+package cidr
+
+import (
+        "fmt"
+        "math/big"
+        "net"
+)
+
+func ipToInt(ip net.IP) (*big.Int, int) {
+        val := &big.Int{}
+        val.SetBytes([]byte(ip))
+        if len(ip) == net.IPv4len {
+                return val, 32
+        } else if len(ip) == net.IPv6len {
+                return val, 128
+        } else {
+                panic(fmt.Errorf("Unsupported address length %d", len(ip)))
+        }
+}
+
+func intToIP(ipInt *big.Int, bits int) net.IP {
+        ipBytes := ipInt.Bytes()
+        ret := make([]byte, bits/8)
+        // Pack our IP bytes into the end of the return array,
+        // since big.Int.Bytes() removes front zero padding.
+        for i := 1; i <= len(ipBytes); i++ {
+                ret[len(ret)-i] = ipBytes[len(ipBytes)-i]
+        }
+        return net.IP(ret)
+}
+
+func insertNumIntoIP(ip net.IP, num int, prefixLen int) net.IP {
+        ipInt, totalBits := ipToInt(ip)
+        bigNum := big.NewInt(int64(num))
+        bigNum.Lsh(bigNum, uint(totalBits-prefixLen))
+        ipInt.Or(ipInt, bigNum)
+        return intToIP(ipInt, totalBits)
+}