@@ -7,6 +7,7 @@ import (

 	"github.com/dotcloud/docker/archive"

 	"github.com/dotcloud/docker/execdriver"

 	"github.com/dotcloud/docker/graphdriver"

+	"github.com/dotcloud/docker/networkdriver/ipallocator"

 	"github.com/dotcloud/docker/pkg/mount"

 	"github.com/dotcloud/docker/pkg/term"

 	"github.com/dotcloud/docker/utils"

@@ -1039,8 +1040,9 @@ func (container *Container) allocateNetwork() error {

 				manager: manager,

 			}

 			if iface != nil && iface.IPNet.IP != nil {

-				ipNum := ipToInt(iface.IPNet.IP)

-				manager.ipAllocator.inUse[ipNum] = struct{}{}

+				if _, err := ipallocator.RequestIP(manager.bridgeNetwork, &iface.IPNet.IP); err != nil {

+					return err

+				}

 			} else {

 				iface, err = container.runtime.networkManager.Allocate()

 				if err != nil {

@@ -1,8 +1,8 @@

 package docker

 import (

-	"errors"

 	"fmt"

+	"github.com/dotcloud/docker/networkdriver/ipallocator"

 	"github.com/dotcloud/docker/pkg/iptables"

 	"github.com/dotcloud/docker/pkg/netlink"

 	"github.com/dotcloud/docker/proxy"

@@ -24,21 +24,6 @@ const (

 	siocBRADDBR          = 0x89a0

 )

-func checkNameserverOverlaps(nameservers []string, dockerNetwork *net.IPNet) error {

-	if len(nameservers) > 0 {

-		for _, ns := range nameservers {

-			_, nsNetwork, err := net.ParseCIDR(ns)

-			if err != nil {

-				return err

-			}

-			if networkOverlaps(dockerNetwork, nsNetwork) {

-				return fmt.Errorf("%s overlaps nameserver %s", dockerNetwork, nsNetwork)

-			}

-		}

-	}

-	return nil

-}

-

 // CreateBridgeIface creates a network bridge interface on the host system with the name `ifaceName`,

 // and attempts to configure it with an address which doesn't conflict with any other interface on the host.

 // If it can't find an address which doesn't conflict, it will return an error.

@@ -86,17 +71,16 @@ func CreateBridgeIface(config *DaemonConfig) error {

 			if err != nil {

 				return err

 			}

-			// TODO: @crosbymichael register route

-			if err := checkRouteOverlaps(routes, dockerNetwork); err == nil {

-				if err := checkNameserverOverlaps(nameservers, dockerNetwork); err == nil {

-					ifaceAddr = addr

-					break

-				}

+

+			if err := ipallocator.RegisterNetwork(dockerNetwork, nameservers); err == nil {

+				ifaceAddr = addr

+				break

 			} else {

 				utils.Debugf("%s: %s", addr, err)

 			}

 		}

 	}

+

 	if ifaceAddr == "" {

 		return fmt.Errorf("Could not find a free IP address range for interface '%s'. Please configure its address manually and run 'docker -b %s'", config.BridgeIface, config.BridgeIface)

 	}

@@ -367,54 +351,6 @@ func newPortAllocator() (*PortAllocator, error) {

 	return allocator, nil

 }

-// IP allocator: Automatically allocate and release networking ports

-type IPAllocator struct {

-	network       *net.IPNet

-	queueAlloc    chan allocatedIP

-	queueReleased chan net.IP

-	inUse         map[int32]struct{}

-	quit          chan bool

-}

-

-type allocatedIP struct {

-	ip  net.IP

-	err error

-}

-

-func (alloc *IPAllocator) run() {

-}

-

-func (alloc *IPAllocator) Acquire() (net.IP, error) {

-	ip := <-alloc.queueAlloc

-	return ip.ip, ip.err

-}

-

-func (alloc *IPAllocator) Release(ip net.IP) {

-	alloc.queueReleased <- ip

-}

-

-func (alloc *IPAllocator) Close() error {

-	alloc.quit <- true

-	close(alloc.quit)

-	close(alloc.queueAlloc)

-	close(alloc.queueReleased)

-	return nil

-}

-

-func newIPAllocator(network *net.IPNet) *IPAllocator {

-	alloc := &IPAllocator{

-		network:       network,

-		queueAlloc:    make(chan allocatedIP),

-		queueReleased: make(chan net.IP),

-		inUse:         make(map[int32]struct{}),

-		quit:          make(chan bool),

-	}

-

-	go alloc.run()

-

-	return alloc

-}

-

 // Network interface represents the networking stack of a container

 type NetworkInterface struct {

 	IPNet   net.IPNet

@@ -519,7 +455,9 @@ func (iface *NetworkInterface) Release() {

 		}

 	}

-	iface.manager.ipAllocator.Release(iface.IPNet.IP)

+	if err := ipallocator.ReleaseIP(iface.manager.bridgeNetwork, &iface.IPNet.IP); err != nil {

+		log.Printf("Unable to release ip %s\n", err)

+	}

 }

 // Network Manager manages a set of network interfaces

@@ -528,7 +466,6 @@ type NetworkManager struct {

 	bridgeIface   string

 	bridgeNetwork *net.IPNet

-	ipAllocator      *IPAllocator

 	tcpPortAllocator *PortAllocator

 	udpPortAllocator *PortAllocator

 	portMapper       *PortMapper

@@ -543,27 +480,31 @@ func (manager *NetworkManager) Allocate() (*NetworkInterface, error) {

 		return &NetworkInterface{disabled: true}, nil

 	}

-	var ip net.IP

+	var ip *net.IP

 	var err error

-	ip, err = manager.ipAllocator.Acquire()

+	ip, err = ipallocator.RequestIP(manager.bridgeNetwork, nil)

 	if err != nil {

 		return nil, err

 	}

-	// avoid duplicate IP

-	ipNum := ipToInt(ip)

-	firstIP := manager.ipAllocator.network.IP.To4().Mask(manager.ipAllocator.network.Mask)

-	firstIPNum := ipToInt(firstIP) + 1

-	if firstIPNum == ipNum {

-		ip, err = manager.ipAllocator.Acquire()

-		if err != nil {

-			return nil, err

+	// TODO: @crosbymichael why are we doing this ?

+	/*

+		// avoid duplicate IP

+		ipNum := ipToInt(ip)

+		firstIP := manager.ipAllocator.network.IP.To4().Mask(manager.ipAllocator.network.Mask)

+		firstIPNum := ipToInt(firstIP) + 1

+

+		if firstIPNum == ipNum {

+			ip, err = manager.ipAllocator.Acquire()

+			if err != nil {

+				return nil, err

+			}

 		}

-	}

+	*/

 	iface := &NetworkInterface{

-		IPNet:   net.IPNet{IP: ip, Mask: manager.bridgeNetwork.Mask},

+		IPNet:   net.IPNet{IP: *ip, Mask: manager.bridgeNetwork.Mask},

 		Gateway: manager.bridgeNetwork.IP,

 		manager: manager,

 	}

@@ -576,14 +517,13 @@ func (manager *NetworkManager) Close() error {

 	}

 	err1 := manager.tcpPortAllocator.Close()

 	err2 := manager.udpPortAllocator.Close()

-	err3 := manager.ipAllocator.Close()

 	if err1 != nil {

 		return err1

 	}

 	if err2 != nil {

 		return err2

 	}

-	return err3

+	return nil

 }

 func newNetworkManager(config *DaemonConfig) (*NetworkManager, error) {

@@ -670,8 +610,6 @@ func newNetworkManager(config *DaemonConfig) (*NetworkManager, error) {

 		}

 	}

-	ipAllocator := newIPAllocator(network)

-

 	tcpPortAllocator, err := newPortAllocator()

 	if err != nil {

 		return nil, err

@@ -690,7 +628,6 @@ func newNetworkManager(config *DaemonConfig) (*NetworkManager, error) {

 	manager := &NetworkManager{

 		bridgeIface:      config.BridgeIface,

 		bridgeNetwork:    network,

-		ipAllocator:      ipAllocator,

 		tcpPortAllocator: tcpPortAllocator,

 		udpPortAllocator: udpPortAllocator,

 		portMapper:       portMapper,

@@ -2,9 +2,7 @@ package docker

 import (

 	"github.com/dotcloud/docker/pkg/iptables"

-	"github.com/dotcloud/docker/pkg/netlink"

 	"github.com/dotcloud/docker/proxy"

-

 	"net"

 	"testing"

 )

@@ -53,277 +51,6 @@ func TestPortAllocation(t *testing.T) {

 	}

 }

-func TestNetworkRange(t *testing.T) {

-	// Simple class C test

-	_, network, _ := net.ParseCIDR("192.168.0.1/24")

-	first, last := networkRange(network)

-	if !first.Equal(net.ParseIP("192.168.0.0")) {

-		t.Error(first.String())

-	}

-	if !last.Equal(net.ParseIP("192.168.0.255")) {

-		t.Error(last.String())

-	}

-	if size := networkSize(network.Mask); size != 256 {

-		t.Error(size)

-	}

-

-	// Class A test

-	_, network, _ = net.ParseCIDR("10.0.0.1/8")

-	first, last = networkRange(network)

-	if !first.Equal(net.ParseIP("10.0.0.0")) {

-		t.Error(first.String())

-	}

-	if !last.Equal(net.ParseIP("10.255.255.255")) {

-		t.Error(last.String())

-	}

-	if size := networkSize(network.Mask); size != 16777216 {

-		t.Error(size)

-	}

-

-	// Class A, random IP address

-	_, network, _ = net.ParseCIDR("10.1.2.3/8")

-	first, last = networkRange(network)

-	if !first.Equal(net.ParseIP("10.0.0.0")) {

-		t.Error(first.String())

-	}

-	if !last.Equal(net.ParseIP("10.255.255.255")) {

-		t.Error(last.String())

-	}

-

-	// 32bit mask

-	_, network, _ = net.ParseCIDR("10.1.2.3/32")

-	first, last = networkRange(network)

-	if !first.Equal(net.ParseIP("10.1.2.3")) {

-		t.Error(first.String())

-	}

-	if !last.Equal(net.ParseIP("10.1.2.3")) {

-		t.Error(last.String())

-	}

-	if size := networkSize(network.Mask); size != 1 {

-		t.Error(size)

-	}

-

-	// 31bit mask

-	_, network, _ = net.ParseCIDR("10.1.2.3/31")

-	first, last = networkRange(network)

-	if !first.Equal(net.ParseIP("10.1.2.2")) {

-		t.Error(first.String())

-	}

-	if !last.Equal(net.ParseIP("10.1.2.3")) {

-		t.Error(last.String())

-	}

-	if size := networkSize(network.Mask); size != 2 {

-		t.Error(size)

-	}

-

-	// 26bit mask

-	_, network, _ = net.ParseCIDR("10.1.2.3/26")

-	first, last = networkRange(network)

-	if !first.Equal(net.ParseIP("10.1.2.0")) {

-		t.Error(first.String())

-	}

-	if !last.Equal(net.ParseIP("10.1.2.63")) {

-		t.Error(last.String())

-	}

-	if size := networkSize(network.Mask); size != 64 {

-		t.Error(size)

-	}

-}

-

-func TestConversion(t *testing.T) {

-	ip := net.ParseIP("127.0.0.1")

-	i := ipToInt(ip)

-	if i == 0 {

-		t.Fatal("converted to zero")

-	}

-	conv := intToIP(i)

-	if !ip.Equal(conv) {

-		t.Error(conv.String())

-	}

-}

-

-func TestIPAllocator(t *testing.T) {

-	expectedIPs := []net.IP{

-		0: net.IPv4(127, 0, 0, 2),

-		1: net.IPv4(127, 0, 0, 3),

-		2: net.IPv4(127, 0, 0, 4),

-		3: net.IPv4(127, 0, 0, 5),

-		4: net.IPv4(127, 0, 0, 6),

-	}

-

-	gwIP, n, _ := net.ParseCIDR("127.0.0.1/29")

-	alloc := newIPAllocator(&net.IPNet{IP: gwIP, Mask: n.Mask})

-	// Pool after initialisation (f = free, u = used)

-	// 2(f) - 3(f) - 4(f) - 5(f) - 6(f)

-	//  ↑

-

-	// Check that we get 5 IPs, from 127.0.0.2–127.0.0.6, in that

-	// order.

-	for i := 0; i < 5; i++ {

-		ip, err := alloc.Acquire()

-		if err != nil {

-			t.Fatal(err)

-		}

-

-		assertIPEquals(t, expectedIPs[i], ip)

-	}

-	// Before loop begin

-	// 2(f) - 3(f) - 4(f) - 5(f) - 6(f)

-	//  ↑

-

-	// After i = 0

-	// 2(u) - 3(f) - 4(f) - 5(f) - 6(f)

-	//         ↑

-

-	// After i = 1

-	// 2(u) - 3(u) - 4(f) - 5(f) - 6(f)

-	//                ↑

-

-	// After i = 2

-	// 2(u) - 3(u) - 4(u) - 5(f) - 6(f)

-	//                       ↑

-

-	// After i = 3

-	// 2(u) - 3(u) - 4(u) - 5(u) - 6(f)

-	//                              ↑

-

-	// After i = 4

-	// 2(u) - 3(u) - 4(u) - 5(u) - 6(u)

-	//  ↑

-

-	// Check that there are no more IPs

-	_, err := alloc.Acquire()

-	if err == nil {

-		t.Fatal("There shouldn't be any IP addresses at this point")

-	}

-

-	// Release some IPs in non-sequential order

-	alloc.Release(expectedIPs[3])

-	// 2(u) - 3(u) - 4(u) - 5(f) - 6(u)

-	//                       ↑

-

-	alloc.Release(expectedIPs[2])

-	// 2(u) - 3(u) - 4(f) - 5(f) - 6(u)

-	//                       ↑

-

-	alloc.Release(expectedIPs[4])

-	// 2(u) - 3(u) - 4(f) - 5(f) - 6(f)

-	//                       ↑

-

-	// Make sure that IPs are reused in sequential order, starting

-	// with the first released IP

-	newIPs := make([]net.IP, 3)

-	for i := 0; i < 3; i++ {

-		ip, err := alloc.Acquire()

-		if err != nil {

-			t.Fatal(err)

-		}

-

-		newIPs[i] = ip

-	}

-	// Before loop begin

-	// 2(u) - 3(u) - 4(f) - 5(f) - 6(f)

-	//                       ↑

-

-	// After i = 0

-	// 2(u) - 3(u) - 4(f) - 5(u) - 6(f)

-	//                              ↑

-

-	// After i = 1

-	// 2(u) - 3(u) - 4(f) - 5(u) - 6(u)

-	//                ↑

-

-	// After i = 2

-	// 2(u) - 3(u) - 4(u) - 5(u) - 6(u)

-	//                       ↑

-

-	assertIPEquals(t, expectedIPs[3], newIPs[0])

-	assertIPEquals(t, expectedIPs[4], newIPs[1])

-	assertIPEquals(t, expectedIPs[2], newIPs[2])

-

-	_, err = alloc.Acquire()

-	if err == nil {

-		t.Fatal("There shouldn't be any IP addresses at this point")

-	}

-}

-

-func assertIPEquals(t *testing.T, ip1, ip2 net.IP) {

-	if !ip1.Equal(ip2) {

-		t.Fatalf("Expected IP %s, got %s", ip1, ip2)

-	}

-}

-

-func AssertOverlap(CIDRx string, CIDRy string, t *testing.T) {

-	_, netX, _ := net.ParseCIDR(CIDRx)

-	_, netY, _ := net.ParseCIDR(CIDRy)

-	if !networkOverlaps(netX, netY) {

-		t.Errorf("%v and %v should overlap", netX, netY)

-	}

-}

-

-func AssertNoOverlap(CIDRx string, CIDRy string, t *testing.T) {

-	_, netX, _ := net.ParseCIDR(CIDRx)

-	_, netY, _ := net.ParseCIDR(CIDRy)

-	if networkOverlaps(netX, netY) {

-		t.Errorf("%v and %v should not overlap", netX, netY)

-	}

-}

-

-func TestNetworkOverlaps(t *testing.T) {

-	//netY starts at same IP and ends within netX

-	AssertOverlap("172.16.0.1/24", "172.16.0.1/25", t)

-	//netY starts within netX and ends at same IP

-	AssertOverlap("172.16.0.1/24", "172.16.0.128/25", t)

-	//netY starts and ends within netX

-	AssertOverlap("172.16.0.1/24", "172.16.0.64/25", t)

-	//netY starts at same IP and ends outside of netX

-	AssertOverlap("172.16.0.1/24", "172.16.0.1/23", t)

-	//netY starts before and ends at same IP of netX

-	AssertOverlap("172.16.1.1/24", "172.16.0.1/23", t)

-	//netY starts before and ends outside of netX

-	AssertOverlap("172.16.1.1/24", "172.16.0.1/23", t)

-	//netY starts and ends before netX

-	AssertNoOverlap("172.16.1.1/25", "172.16.0.1/24", t)

-	//netX starts and ends before netY

-	AssertNoOverlap("172.16.1.1/25", "172.16.2.1/24", t)

-}

-

-func TestCheckRouteOverlaps(t *testing.T) {

-	routesData := []string{"10.0.2.0/32", "10.0.3.0/24", "10.0.42.0/24", "172.16.42.0/24", "192.168.142.0/24"}

-

-	routes := []netlink.Route{}

-	for _, addr := range routesData {

-		_, netX, _ := net.ParseCIDR(addr)

-		routes = append(routes, netlink.Route{IPNet: netX})

-	}

-

-	_, netX, _ := net.ParseCIDR("172.16.0.1/24")

-	if err := checkRouteOverlaps(routes, netX); err != nil {

-		t.Fatal(err)

-	}

-

-	_, netX, _ = net.ParseCIDR("10.0.2.0/24")

-	if err := checkRouteOverlaps(routes, netX); err == nil {

-		t.Fatalf("10.0.2.0/24 and 10.0.2.0 should overlap but it doesn't")

-	}

-}

-

-func TestCheckNameserverOverlaps(t *testing.T) {

-	nameservers := []string{"10.0.2.3/32", "192.168.102.1/32"}

-

-	_, netX, _ := net.ParseCIDR("10.0.2.3/32")

-

-	if err := checkNameserverOverlaps(nameservers, netX); err == nil {

-		t.Fatalf("%s should overlap 10.0.2.3/32 but doesn't", netX)

-	}

-

-	_, netX, _ = net.ParseCIDR("192.168.102.2/32")

-

-	if err := checkNameserverOverlaps(nameservers, netX); err != nil {

-		t.Fatalf("%s should not overlap %v but it does", netX, nameservers)

-	}

-}

-

 type StubProxy struct {

 	frontendAddr *net.Addr

 	backendAddr  *net.Addr

@@ -16,20 +16,25 @@ type iPNet struct {

 }

 var (

-	ErrNetworkAlreadyAllocated = errors.New("requested network overlaps with existing network")

-	ErrNetworkAlreadyRegisterd = errors.New("requested network is already registered")

-	ErrNoAvailableIps          = errors.New("no available ips on network")

-	ErrIPAlreadyAllocated      = errors.New("ip already allocated")

+	ErrNetworkAlreadyAllocated        = errors.New("requested network overlaps with existing network")

+	ErrNetworkAlreadyRegisterd        = errors.New("requested network is already registered")

+	ErrNetworkOverlapsWithNameservers = errors.New("requested network overlaps with nameserver")

+	ErrNoAvailableIps                 = errors.New("no available ips on network")

+	ErrIPAlreadyAllocated             = errors.New("ip already allocated")

 	lock         = sync.Mutex{}

 	allocatedIPs = networkSet{}

 	availableIPS = networkSet{}

 )

-func RegisterNetwork(network *net.IPNet) error {

+func RegisterNetwork(network *net.IPNet, nameservers []string) error {

 	lock.Lock()

 	defer lock.Unlock()

+	if err := checkExistingNetworkOverlaps(network); err != nil {

+		return err

+	}

+

 	routes, err := netlink.NetworkGetRoutes()

 	if err != nil {

 		return err

@@ -39,9 +44,10 @@ func RegisterNetwork(network *net.IPNet) error {

 		return err

 	}

-	if err := checkExistingNetworkOverlaps(network); err != nil {

+	if err := checkNameserverOverlaps(nameservers, network); err != nil {

 		return err

 	}

+

 	n := newIPNet(network)

 	allocatedIPs[n] = &iPSet{}

@@ -227,3 +233,18 @@ func networkSize(mask net.IPMask) int32 {

 	return int32(binary.BigEndian.Uint32(m)) + 1

 }

+

+func checkNameserverOverlaps(nameservers []string, toCheck *net.IPNet) error {

+	if len(nameservers) > 0 {

+		for _, ns := range nameservers {

+			_, nsNetwork, err := net.ParseCIDR(ns)

+			if err != nil {

+				return err

+			}

+			if networkOverlaps(toCheck, nsNetwork) {

+				return ErrNetworkOverlapsWithNameservers

+			}

+		}

+	}

+	return nil

+}

@@ -2,6 +2,7 @@ package ipallocator

 import (

 	"fmt"

+	"github.com/dotcloud/docker/pkg/netlink"

 	"net"

 	"testing"

 )

@@ -18,7 +19,7 @@ func TestRegisterNetwork(t *testing.T) {

 		Mask: []byte{255, 255, 255, 0},

 	}

-	if err := RegisterNetwork(network); err != nil {

+	if err := RegisterNetwork(network, nil); err != nil {

 		t.Fatal(err)

 	}

@@ -39,7 +40,7 @@ func TestRegisterTwoNetworks(t *testing.T) {

 		Mask: []byte{255, 255, 255, 0},

 	}

-	if err := RegisterNetwork(network); err != nil {

+	if err := RegisterNetwork(network, nil); err != nil {

 		t.Fatal(err)

 	}

@@ -48,7 +49,7 @@ func TestRegisterTwoNetworks(t *testing.T) {

 		Mask: []byte{255, 255, 255, 0},

 	}

-	if err := RegisterNetwork(network2); err != nil {

+	if err := RegisterNetwork(network2, nil); err != nil {

 		t.Fatal(err)

 	}

 }

@@ -60,11 +61,11 @@ func TestRegisterNetworkThatExists(t *testing.T) {

 		Mask: []byte{255, 255, 255, 0},

 	}

-	if err := RegisterNetwork(network); err != nil {

+	if err := RegisterNetwork(network, nil); err != nil {

 		t.Fatal(err)

 	}

-	if err := RegisterNetwork(network); err != ErrNetworkAlreadyRegisterd {

+	if err := RegisterNetwork(network, nil); err != ErrNetworkAlreadyRegisterd {

 		t.Fatalf("Expected error of %s got %s", ErrNetworkAlreadyRegisterd, err)

 	}

 }

@@ -76,7 +77,7 @@ func TestRequestNewIps(t *testing.T) {

 		Mask: []byte{255, 255, 255, 0},

 	}

-	if err := RegisterNetwork(network); err != nil {

+	if err := RegisterNetwork(network, nil); err != nil {

 		t.Fatal(err)

 	}

@@ -99,7 +100,7 @@ func TestReleaseIp(t *testing.T) {

 		Mask: []byte{255, 255, 255, 0},

 	}

-	if err := RegisterNetwork(network); err != nil {

+	if err := RegisterNetwork(network, nil); err != nil {

 		t.Fatal(err)

 	}

@@ -120,7 +121,7 @@ func TestGetReleasedIp(t *testing.T) {

 		Mask: []byte{255, 255, 255, 0},

 	}

-	if err := RegisterNetwork(network); err != nil {

+	if err := RegisterNetwork(network, nil); err != nil {

 		t.Fatal(err)

 	}

@@ -151,7 +152,7 @@ func TestRequesetSpecificIp(t *testing.T) {

 		Mask: []byte{255, 255, 255, 0},

 	}

-	if err := RegisterNetwork(network); err != nil {

+	if err := RegisterNetwork(network, nil); err != nil {

 		t.Fatal(err)

 	}

@@ -161,3 +162,313 @@ func TestRequesetSpecificIp(t *testing.T) {

 		t.Fatal(err)

 	}

 }

+

+func TestNonOverlapingNameservers(t *testing.T) {

+	defer reset()

+	network := &net.IPNet{

+		IP:   []byte{192, 168, 0, 1},

+		Mask: []byte{255, 255, 255, 0},

+	}

+	nameservers := []string{

+		"127.0.0.1/32",

+	}

+

+	if err := RegisterNetwork(network, nameservers); err != nil {

+		t.Fatal(err)

+	}

+}

+

+func TestOverlapingNameservers(t *testing.T) {

+	defer reset()

+	network := &net.IPNet{

+		IP:   []byte{192, 168, 0, 1},

+		Mask: []byte{255, 255, 255, 0},

+	}

+	nameservers := []string{

+		"192.168.0.1/32",

+	}

+

+	if err := RegisterNetwork(network, nameservers); err != ErrNetworkOverlapsWithNameservers {

+		t.Fatalf("Expectecd error of %s got %s", ErrNetworkOverlapsWithNameservers, err)

+	}

+}

+

+func TestNetworkRange(t *testing.T) {

+	// Simple class C test

+	_, network, _ := net.ParseCIDR("192.168.0.1/24")

+	first, last := networkRange(network)

+	if !first.Equal(net.ParseIP("192.168.0.0")) {

+		t.Error(first.String())

+	}

+	if !last.Equal(net.ParseIP("192.168.0.255")) {

+		t.Error(last.String())

+	}

+	if size := networkSize(network.Mask); size != 256 {

+		t.Error(size)

+	}

+

+	// Class A test

+	_, network, _ = net.ParseCIDR("10.0.0.1/8")

+	first, last = networkRange(network)

+	if !first.Equal(net.ParseIP("10.0.0.0")) {

+		t.Error(first.String())

+	}

+	if !last.Equal(net.ParseIP("10.255.255.255")) {

+		t.Error(last.String())

+	}

+	if size := networkSize(network.Mask); size != 16777216 {

+		t.Error(size)

+	}

+

+	// Class A, random IP address

+	_, network, _ = net.ParseCIDR("10.1.2.3/8")

+	first, last = networkRange(network)

+	if !first.Equal(net.ParseIP("10.0.0.0")) {

+		t.Error(first.String())

+	}

+	if !last.Equal(net.ParseIP("10.255.255.255")) {

+		t.Error(last.String())

+	}

+

+	// 32bit mask

+	_, network, _ = net.ParseCIDR("10.1.2.3/32")

+	first, last = networkRange(network)

+	if !first.Equal(net.ParseIP("10.1.2.3")) {

+		t.Error(first.String())

+	}

+	if !last.Equal(net.ParseIP("10.1.2.3")) {

+		t.Error(last.String())

+	}

+	if size := networkSize(network.Mask); size != 1 {

+		t.Error(size)

+	}

+

+	// 31bit mask

+	_, network, _ = net.ParseCIDR("10.1.2.3/31")

+	first, last = networkRange(network)

+	if !first.Equal(net.ParseIP("10.1.2.2")) {

+		t.Error(first.String())

+	}

+	if !last.Equal(net.ParseIP("10.1.2.3")) {

+		t.Error(last.String())

+	}

+	if size := networkSize(network.Mask); size != 2 {

+		t.Error(size)

+	}

+

+	// 26bit mask

+	_, network, _ = net.ParseCIDR("10.1.2.3/26")

+	first, last = networkRange(network)

+	if !first.Equal(net.ParseIP("10.1.2.0")) {

+		t.Error(first.String())

+	}

+	if !last.Equal(net.ParseIP("10.1.2.63")) {

+		t.Error(last.String())

+	}

+	if size := networkSize(network.Mask); size != 64 {

+		t.Error(size)

+	}

+}

+

+func TestConversion(t *testing.T) {

+	ip := net.ParseIP("127.0.0.1")

+	i := ipToInt(&ip)

+	if i == 0 {

+		t.Fatal("converted to zero")

+	}

+	conv := intToIP(i)

+	if !ip.Equal(*conv) {

+		t.Error(conv.String())

+	}

+}

+

+func TestIPAllocator(t *testing.T) {

+	expectedIPs := []net.IP{

+		0: net.IPv4(127, 0, 0, 2),

+		1: net.IPv4(127, 0, 0, 3),

+		2: net.IPv4(127, 0, 0, 4),

+		3: net.IPv4(127, 0, 0, 5),

+		4: net.IPv4(127, 0, 0, 6),

+	}

+

+	gwIP, n, _ := net.ParseCIDR("127.0.0.1/29")

+	network := &net.IPNet{IP: gwIP, Mask: n.Mask}

+	if err := RegisterNetwork(network, nil); err != nil {

+		t.Fatal(err)

+	}

+	// Pool after initialisation (f = free, u = used)

+	// 2(f) - 3(f) - 4(f) - 5(f) - 6(f)

+	//  ↑

+

+	// Check that we get 5 IPs, from 127.0.0.2–127.0.0.6, in that

+	// order.

+	for i := 0; i < 5; i++ {

+		ip, err := RequestIP(network, nil)

+		if err != nil {

+			t.Fatal(err)

+		}

+

+		assertIPEquals(t, &expectedIPs[i], ip)

+	}

+	// Before loop begin

+	// 2(f) - 3(f) - 4(f) - 5(f) - 6(f)

+	//  ↑

+

+	// After i = 0

+	// 2(u) - 3(f) - 4(f) - 5(f) - 6(f)

+	//         ↑

+

+	// After i = 1

+	// 2(u) - 3(u) - 4(f) - 5(f) - 6(f)

+	//                ↑

+

+	// After i = 2

+	// 2(u) - 3(u) - 4(u) - 5(f) - 6(f)

+	//                       ↑

+

+	// After i = 3

+	// 2(u) - 3(u) - 4(u) - 5(u) - 6(f)

+	//                              ↑

+

+	// After i = 4

+	// 2(u) - 3(u) - 4(u) - 5(u) - 6(u)

+	//  ↑

+

+	// Check that there are no more IPs

+	ip, err := RequestIP(network, nil)

+	if err == nil {

+		t.Fatalf("There shouldn't be any IP addresses at this point, got %s\n", ip)

+	}

+

+	// Release some IPs in non-sequential order

+	if err := ReleaseIP(network, &expectedIPs[3]); err != nil {

+		t.Fatal(err)

+	}

+	// 2(u) - 3(u) - 4(u) - 5(f) - 6(u)

+	//                       ↑

+

+	if err := ReleaseIP(network, &expectedIPs[2]); err != nil {

+		t.Fatal(err)

+	}

+	// 2(u) - 3(u) - 4(f) - 5(f) - 6(u)

+	//                       ↑

+

+	if err := ReleaseIP(network, &expectedIPs[4]); err != nil {

+		t.Fatal(err)

+	}

+	// 2(u) - 3(u) - 4(f) - 5(f) - 6(f)

+	//                       ↑

+

+	// Make sure that IPs are reused in sequential order, starting

+	// with the first released IP

+	newIPs := make([]*net.IP, 3)

+	for i := 0; i < 3; i++ {

+		ip, err := RequestIP(network, nil)

+		if err != nil {

+			t.Fatal(err)

+		}

+

+		newIPs[i] = ip

+	}

+	// Before loop begin

+	// 2(u) - 3(u) - 4(f) - 5(f) - 6(f)

+	//                       ↑

+

+	// After i = 0

+	// 2(u) - 3(u) - 4(f) - 5(u) - 6(f)

+	//                              ↑

+

+	// After i = 1

+	// 2(u) - 3(u) - 4(f) - 5(u) - 6(u)

+	//                ↑

+

+	// After i = 2