@@ -5,6 +5,7 @@ package bitseq

 import (

 	"encoding/binary"

+	"encoding/json"

 	"fmt"

 	"sync"

@@ -392,6 +393,38 @@ func (h *Handle) String() string {

 		h.app, h.id, h.dbIndex, h.bits, h.unselected, h.head.toString())

 }

+// MarshalJSON encodes Handle into json message

+func (h *Handle) MarshalJSON() ([]byte, error) {

+	m := map[string]interface{}{

+		"id": h.id,

+	}

+

+	b, err := h.ToByteArray()

+	if err != nil {

+		return nil, err

+	}

+	m["sequence"] = b

+	return json.Marshal(m)

+}

+

+// UnmarshalJSON decodes json message into Handle

+func (h *Handle) UnmarshalJSON(data []byte) error {

+	var (

+		m   map[string]interface{}

+		b   []byte

+		err error

+	)

+	if err = json.Unmarshal(data, &m); err != nil {

+		return err

+	}

+	h.id = m["id"].(string)

+	bi, _ := json.Marshal(m["sequence"])

+	if err := json.Unmarshal(bi, &b); err != nil {

+		return err

+	}

+	return h.FromByteArray(b)

+}

+

 // getFirstAvailable looks for the first unset bit in passed mask starting from start

 func getFirstAvailable(head *sequence, start uint32) (uint32, uint32, error) {

 	// Find sequence which contains the start bit

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

 	"encoding/json"

 	"fmt"

-	log "github.com/Sirupsen/logrus"

 	"github.com/docker/libnetwork/datastore"

 	"github.com/docker/libnetwork/types"

 )

@@ -25,27 +24,16 @@ func (h *Handle) KeyPrefix() []string {

 // Value marshals the data to be stored in the KV store

 func (h *Handle) Value() []byte {

-	b, err := h.ToByteArray()

+	b, err := json.Marshal(h)

 	if err != nil {

-		log.Warnf("Failed to serialize Handle: %v", err)

-		b = []byte{}

-	}

-	jv, err := json.Marshal(b)

-	if err != nil {

-		log.Warnf("Failed to json encode bitseq handler byte array: %v", err)

-		return []byte{}

+		return nil

 	}

-	return jv

+	return b

 }

 // SetValue unmarshals the data from the KV store

 func (h *Handle) SetValue(value []byte) error {

-	var b []byte

-	if err := json.Unmarshal(value, &b); err != nil {

-		return err

-	}

-

-	return h.FromByteArray(b)

+	return json.Unmarshal(value, h)

 }

 // Index returns the latest DB Index as seen by this object

@@ -77,7 +65,6 @@ func (h *Handle) New() datastore.KVObject {

 	return &Handle{

 		app:   h.app,

-		id:    h.id,

 		store: h.store,

 	}

 }

@@ -29,8 +29,10 @@ import (

 	"github.com/docker/libnetwork/config"

 	"github.com/docker/libnetwork/datastore"

 	"github.com/docker/libnetwork/driverapi"

+	"github.com/docker/libnetwork/ipamutils"

 	"github.com/docker/libnetwork/netlabel"

 	"github.com/docker/libnetwork/options"

+	"github.com/docker/libnetwork/types"

 	"github.com/gorilla/mux"

 )

@@ -187,7 +189,12 @@ func createDefaultNetwork(c libnetwork.NetworkController) {

 			}

 			createOptions = append(createOptions,

 				libnetwork.NetworkOptionGeneric(genericOption),

-				libnetwork.NetworkOptionPersist(false))

+				ipamOption(nw))

+		}

+

+		if _, err := c.NetworkByName(nw); err == nil {

+			logrus.Debugf("Default network %s already present", nw)

+			return

 		}

 		_, err := c.NewNetwork(d, nw, createOptions...)

 		if err != nil {

@@ -405,3 +412,15 @@ func encodeData(data interface{}) (*bytes.Buffer, error) {

 	}

 	return params, nil

 }

+

+func ipamOption(bridgeName string) libnetwork.NetworkOption {

+	if nw, _, err := ipamutils.ElectInterfaceAddresses(bridgeName); err == nil {

+		ipamV4Conf := &libnetwork.IpamConf{PreferredPool: nw.String()}

+		hip, _ := types.GetHostPartIP(nw.IP, nw.Mask)

+		if hip.IsGlobalUnicast() {

+			ipamV4Conf.Gateway = nw.IP.String()

+		}

+		return libnetwork.NetworkOptionIpam("default", "", []*libnetwork.IpamConf{ipamV4Conf}, nil)

+	}

+	return nil

+}

@@ -56,15 +56,17 @@ type configuration struct {

 // networkConfiguration for network specific configuration

 type networkConfiguration struct {

 	BridgeName         string

-	AddressIPv4        *net.IPNet

 	EnableIPv6         bool

 	EnableIPMasquerade bool

 	EnableICC          bool

 	Mtu                int

-	DefaultGatewayIPv4 net.IP

-	DefaultGatewayIPv6 net.IP

 	DefaultBindingIP   net.IP

 	DefaultBridge      bool

+	// Internal fields set after ipam data parsing

+	AddressIPv4        *net.IPNet

+	AddressIPv6        *net.IPNet

+	DefaultGatewayIPv4 net.IP

+	DefaultGatewayIPv6 net.IP

 }

 // endpointConfiguration represents the user specified configuration for the sandbox endpoint

@@ -161,27 +163,39 @@ func (c *networkConfiguration) Validate() error {

 		}

 	}

+	// If default v6 gw is specified, AddressIPv6 must be specified and gw must belong to AddressIPv6 subnet

+	if c.EnableIPv6 && c.DefaultGatewayIPv6 != nil {

+		if c.AddressIPv6 == nil || !c.AddressIPv6.Contains(c.DefaultGatewayIPv6) {

+			return &ErrInvalidGateway{}

+		}

+	}

 	return nil

 }

 // Conflicts check if two NetworkConfiguration objects overlap

-func (c *networkConfiguration) Conflicts(o *networkConfiguration) bool {

+func (c *networkConfiguration) Conflicts(o *networkConfiguration) error {

 	if o == nil {

-		return false

+		return fmt.Errorf("same configuration")

 	}

 	// Also empty, becasue only one network with empty name is allowed

 	if c.BridgeName == o.BridgeName {

-		return true

+		return fmt.Errorf("networks have same name")

 	}

 	// They must be in different subnets

 	if (c.AddressIPv4 != nil && o.AddressIPv4 != nil) &&

 		(c.AddressIPv4.Contains(o.AddressIPv4.IP) || o.AddressIPv4.Contains(c.AddressIPv4.IP)) {

-		return true

+		return fmt.Errorf("networks have overlapping IPv4")

+	}

+

+	// They must be in different v6 subnets

+	if (c.AddressIPv6 != nil && o.AddressIPv6 != nil) &&

+		(c.AddressIPv6.Contains(o.AddressIPv6.IP) || o.AddressIPv6.Contains(c.AddressIPv6.IP)) {

+		return fmt.Errorf("networks have overlapping IPv6")

 	}

-	return false

+	return nil

 }

 // fromMap retrieve the configuration data from the map form.

@@ -456,18 +470,18 @@ func (c *networkConfiguration) processIPAM(id string, ipamV4Data, ipamV6Data []d

 		c.AddressIPv4 = types.GetIPNetCopy(ipamV4Data[0].Gateway)

 	}

-	if c.EnableIPv6 && len(ipamV6Data) == 0 {

-		return types.BadRequestErrorf("bridge network %s requires ipv6 configuration", id)

-	}

-

-	gw, ok := ipamV4Data[0].AuxAddresses[DefaultGatewayV4AuxKey]

-	if ok {

+	if gw, ok := ipamV4Data[0].AuxAddresses[DefaultGatewayV4AuxKey]; ok {

 		c.DefaultGatewayIPv4 = gw.IP

 	}

-	gw, ok = ipamV4Data[0].AuxAddresses[DefaultGatewayV6AuxKey]

-	if ok {

-		c.DefaultGatewayIPv6 = gw.IP

+	if len(ipamV6Data) > 0 {

+		if ipamV6Data[0].Gateway != nil {

+			c.AddressIPv6 = types.GetIPNetCopy(ipamV6Data[0].Gateway)

+		}

+

+		if gw, ok := ipamV6Data[0].AuxAddresses[DefaultGatewayV6AuxKey]; ok {

+			c.DefaultGatewayIPv6 = gw.IP

+		}

 	}

 	return nil

@@ -502,6 +516,9 @@ func parseNetworkOptions(id string, option options.Generic) (*networkConfigurati

 // Returns the non link-local IPv6 subnet for the containers attached to this bridge if found, nil otherwise

 func getV6Network(config *networkConfiguration, i *bridgeInterface) *net.IPNet {

+	if config.AddressIPv6 != nil {

+		return config.AddressIPv6

+	}

 	if i.bridgeIPv6 != nil && i.bridgeIPv6.IP != nil && !i.bridgeIPv6.IP.IsLinkLocalUnicast() {

 		return i.bridgeIPv6

 	}

@@ -551,8 +568,9 @@ func (d *driver) CreateNetwork(id string, option map[string]interface{}, ipV4Dat

 		nw.Lock()

 		nwConfig := nw.config

 		nw.Unlock()

-		if nwConfig.Conflicts(config) {

-			return types.ForbiddenErrorf("conflicts with network %s (%s)", nw.id, nw.config.BridgeName)

+		if err := nwConfig.Conflicts(config); err != nil {

+			return types.ForbiddenErrorf("cannot create network %s (%s): conflicts with network %s (%s): %s",

+				nwConfig.BridgeName, id, nw.id, nw.config.BridgeName, err.Error())

 		}

 	}

@@ -613,10 +631,7 @@ func (d *driver) CreateNetwork(id string, option map[string]interface{}, ipV4Dat

 	// Even if a bridge exists try to setup IPv4.

 	bridgeSetup.queueStep(setupBridgeIPv4)

-	enableIPv6Forwarding := false

-	if d.config.EnableIPForwarding {

-		enableIPv6Forwarding = true

-	}

+	enableIPv6Forwarding := d.config.EnableIPForwarding && config.AddressIPv6 != nil

 	// Conditionally queue setup steps depending on configuration values.

 	for _, step := range []struct {

@@ -797,11 +812,6 @@ func setHairpinMode(link netlink.Link, enable bool) error {

 }

 func (d *driver) CreateEndpoint(nid, eid string, ifInfo driverapi.InterfaceInfo, epOptions map[string]interface{}) error {

-	var (

-		ipv6Addr *net.IPNet

-		err      error

-	)

-

 	defer osl.InitOSContext()()

 	if ifInfo == nil {

@@ -931,7 +941,11 @@ func (d *driver) CreateEndpoint(nid, eid string, ifInfo driverapi.InterfaceInfo,

 		}

 	}

-	ipv4Addr := ifInfo.Address()

+	// Create the sandbox side pipe interface

+	endpoint.srcName = containerIfName

+	endpoint.macAddress = ifInfo.MacAddress()

+	endpoint.addr = ifInfo.Address()

+	endpoint.addrv6 = ifInfo.AddressIPv6()

 	// Down the interface before configuring mac address.

 	if err = netlink.LinkSetDown(sbox); err != nil {

@@ -939,28 +953,38 @@ func (d *driver) CreateEndpoint(nid, eid string, ifInfo driverapi.InterfaceInfo,

 	}

 	// Set the sbox's MAC. If specified, use the one configured by user, otherwise generate one based on IP.

-	mac := ifInfo.MacAddress()

-	if mac == nil {

-		mac = electMacAddress(epConfig, ipv4Addr.IP)

+	if endpoint.macAddress == nil {

+		endpoint.macAddress = electMacAddress(epConfig, endpoint.addr.IP)

+		if err := ifInfo.SetMacAddress(endpoint.macAddress); err != nil {

+			return err

+		}

 	}

-	err = netlink.LinkSetHardwareAddr(sbox, mac)

+	err = netlink.LinkSetHardwareAddr(sbox, endpoint.macAddress)

 	if err != nil {

 		return fmt.Errorf("could not set mac address for container interface %s: %v", containerIfName, err)

 	}

-	endpoint.macAddress = mac

 	// Up the host interface after finishing all netlink configuration

 	if err = netlink.LinkSetUp(host); err != nil {

 		return fmt.Errorf("could not set link up for host interface %s: %v", hostIfName, err)

 	}

-	ipv6Addr = ifInfo.AddressIPv6()

-	// Create the sandbox side pipe interface

-	endpoint.srcName = containerIfName

-	endpoint.addr = ipv4Addr

+	if endpoint.addrv6 == nil && config.EnableIPv6 {

+		var ip6 net.IP

+		network := n.bridge.bridgeIPv6

+		ones, _ := network.Mask.Size()

+		if ones <= 80 {

+			ip6 = make(net.IP, len(network.IP))

+			copy(ip6, network.IP)

+			for i, h := range endpoint.macAddress {

+				ip6[i+10] = h

+			}

+		}

-	if config.EnableIPv6 {

-		endpoint.addrv6 = ipv6Addr

+		endpoint.addrv6 = &net.IPNet{IP: ip6, Mask: network.Mask}

+		if err := ifInfo.SetIPAddress(endpoint.addrv6); err != nil {

+			return err

+		}

 	}

 	// Program any required port mapping and store them in the endpoint

@@ -969,13 +993,6 @@ func (d *driver) CreateEndpoint(nid, eid string, ifInfo driverapi.InterfaceInfo,

 		return err

 	}

-	if ifInfo.MacAddress() == nil {

-		err = ifInfo.SetMacAddress(endpoint.macAddress)

-		if err != nil {

-			return err

-		}

-	}

-

 	return nil

 }

@@ -8,14 +8,27 @@ import (

 	"testing"

 	"github.com/docker/libnetwork/driverapi"

+	"github.com/docker/libnetwork/ipamutils"

 	"github.com/docker/libnetwork/iptables"

 	"github.com/docker/libnetwork/netlabel"

-	"github.com/docker/libnetwork/netutils"

 	"github.com/docker/libnetwork/testutils"

 	"github.com/docker/libnetwork/types"

 	"github.com/vishvananda/netlink"

 )

+func getIPv4Data(t *testing.T) []driverapi.IPAMData {

+	ipd := driverapi.IPAMData{AddressSpace: "full"}

+	nw, _, err := ipamutils.ElectInterfaceAddresses("")

+	if err != nil {

+		t.Fatal(err)

+	}

+	ipd.Pool = nw

+	// Set network gateway to X.X.X.1

+	ipd.Gateway = types.GetIPNetCopy(nw)

+	ipd.Gateway.IP[len(ipd.Gateway.IP)-1] = 1

+	return []driverapi.IPAMData{ipd}

+}

+

 func TestCreateFullOptions(t *testing.T) {

 	defer testutils.SetupTestOSContext(t)()

 	d := newDriver()

@@ -27,17 +40,14 @@ func TestCreateFullOptions(t *testing.T) {

 	// Test this scenario: Default gw address does not belong to

 	// container network and it's greater than bridge address

-	cip, cnw, _ := net.ParseCIDR("172.16.122.0/24")

-	cnw.IP = cip

-	ip, nw, _ := net.ParseCIDR("172.16.0.10/16")

-	nw.IP = ip

-	gw := net.ParseIP("172.16.0.1")

+	cnw, _ := types.ParseCIDR("172.16.122.0/24")

+	bnw, _ := types.ParseCIDR("172.16.0.0/24")

+	br, _ := types.ParseCIDR("172.16.0.1/16")

+	defgw, _ := types.ParseCIDR("172.16.0.100/16")

 	netConfig := &networkConfiguration{

-		BridgeName:         DefaultBridgeName,

-		AddressIPv4:        nw,

-		DefaultGatewayIPv4: gw,

-		EnableIPv6:         true,

+		BridgeName: DefaultBridgeName,

+		EnableIPv6: true,

 	}

 	genericOption := make(map[string]interface{})

 	genericOption[netlabel.GenericData] = config

@@ -49,14 +59,21 @@ func TestCreateFullOptions(t *testing.T) {

 	netOption := make(map[string]interface{})

 	netOption[netlabel.GenericData] = netConfig

-	err := d.CreateNetwork("dummy", netOption, nil, nil)

+	ipdList := []driverapi.IPAMData{

+		driverapi.IPAMData{

+			Pool:         bnw,

+			Gateway:      br,

+			AuxAddresses: map[string]*net.IPNet{DefaultGatewayV4AuxKey: defgw},

+		},

+	}

+	err := d.CreateNetwork("dummy", netOption, ipdList, nil)

 	if err != nil {

 		t.Fatalf("Failed to create bridge: %v", err)

 	}

 	// Verify the IP address allocated for the endpoint belongs to the container network

 	epOptions := make(map[string]interface{})

-	te := &testEndpoint{iface: &testInterface{}}

+	te := newTestEndpoint(cnw, 10)

 	err = d.CreateEndpoint("dummy", "ep1", te.Interface(), epOptions)

 	if err != nil {

 		t.Fatalf("Failed to create an endpoint : %s", err.Error())

@@ -75,7 +92,7 @@ func TestCreateNoConfig(t *testing.T) {

 	genericOption := make(map[string]interface{})

 	genericOption[netlabel.GenericData] = netconfig

-	if err := d.CreateNetwork("dummy", genericOption, nil, nil); err != nil {

+	if err := d.CreateNetwork("dummy", genericOption, getIPv4Data(t), nil); err != nil {

 		t.Fatalf("Failed to create bridge: %v", err)

 	}

 }

@@ -92,11 +109,11 @@ func TestCreate(t *testing.T) {

 	genericOption := make(map[string]interface{})

 	genericOption[netlabel.GenericData] = netconfig

-	if err := d.CreateNetwork("dummy", genericOption, nil, nil); err != nil {

+	if err := d.CreateNetwork("dummy", genericOption, getIPv4Data(t), nil); err != nil {

 		t.Fatalf("Failed to create bridge: %v", err)

 	}

-	err := d.CreateNetwork("dummy", genericOption, nil, nil)

+	err := d.CreateNetwork("dummy", genericOption, getIPv4Data(t), nil)

 	if err == nil {

 		t.Fatalf("Expected bridge driver to refuse creation of second network with default name")

 	}

@@ -125,7 +142,7 @@ func TestCreateFail(t *testing.T) {

 	genericOption := make(map[string]interface{})

 	genericOption[netlabel.GenericData] = netconfig

-	if err := d.CreateNetwork("dummy", genericOption, nil, nil); err == nil {

+	if err := d.CreateNetwork("dummy", genericOption, getIPv4Data(t), nil); err == nil {

 		t.Fatal("Bridge creation was expected to fail")

 	}

 }

@@ -147,19 +164,19 @@ func TestCreateMultipleNetworks(t *testing.T) {

 	config1 := &networkConfiguration{BridgeName: "net_test_1"}

 	genericOption = make(map[string]interface{})

 	genericOption[netlabel.GenericData] = config1

-	if err := d.CreateNetwork("1", genericOption, nil, nil); err != nil {

+	if err := d.CreateNetwork("1", genericOption, getIPv4Data(t), nil); err != nil {

 		t.Fatalf("Failed to create bridge: %v", err)

 	}

 	config2 := &networkConfiguration{BridgeName: "net_test_2"}

 	genericOption[netlabel.GenericData] = config2

-	if err := d.CreateNetwork("2", genericOption, nil, nil); err != nil {

+	if err := d.CreateNetwork("2", genericOption, getIPv4Data(t), nil); err != nil {

 		t.Fatalf("Failed to create bridge: %v", err)

 	}

 	config3 := &networkConfiguration{BridgeName: "net_test_3"}

 	genericOption[netlabel.GenericData] = config3

-	if err := d.CreateNetwork("3", genericOption, nil, nil); err != nil {

+	if err := d.CreateNetwork("3", genericOption, getIPv4Data(t), nil); err != nil {

 		t.Fatalf("Failed to create bridge: %v", err)

 	}

@@ -168,7 +185,7 @@ func TestCreateMultipleNetworks(t *testing.T) {

 	config4 := &networkConfiguration{BridgeName: "net_test_4"}

 	genericOption[netlabel.GenericData] = config4

-	if err := d.CreateNetwork("4", genericOption, nil, nil); err != nil {

+	if err := d.CreateNetwork("4", genericOption, getIPv4Data(t), nil); err != nil {

 		t.Fatalf("Failed to create bridge: %v", err)

 	}

@@ -221,6 +238,12 @@ type testEndpoint struct {

 	routes         []types.StaticRoute

 }

+func newTestEndpoint(nw *net.IPNet, ordinal byte) *testEndpoint {

+	addr := types.GetIPNetCopy(nw)

+	addr.IP[len(addr.IP)-1] = ordinal

+	return &testEndpoint{iface: &testInterface{addr: addr}}

+}

+

 func (te *testEndpoint) Interface() driverapi.InterfaceInfo {

 	if te.iface != nil {

 		return te.iface

@@ -329,7 +352,8 @@ func testQueryEndpointInfo(t *testing.T, ulPxyEnabled bool) {

 	genericOption = make(map[string]interface{})

 	genericOption[netlabel.GenericData] = netconfig

-	err := d.CreateNetwork("net1", genericOption, nil, nil)

+	ipdList := getIPv4Data(t)

+	err := d.CreateNetwork("net1", genericOption, ipdList, nil)

 	if err != nil {

 		t.Fatalf("Failed to create bridge: %v", err)

 	}

@@ -338,7 +362,7 @@ func testQueryEndpointInfo(t *testing.T, ulPxyEnabled bool) {

 	epOptions := make(map[string]interface{})

 	epOptions[netlabel.PortMap] = portMappings

-	te := &testEndpoint{iface: &testInterface{}}

+	te := newTestEndpoint(ipdList[0].Pool, 11)

 	err = d.CreateEndpoint("net1", "ep1", te.Interface(), epOptions)

 	if err != nil {

 		t.Fatalf("Failed to create an endpoint : %s", err.Error())

@@ -389,7 +413,8 @@ func TestCreateLinkWithOptions(t *testing.T) {

 	netOptions := make(map[string]interface{})

 	netOptions[netlabel.GenericData] = netconfig

-	err := d.CreateNetwork("net1", netOptions, nil, nil)

+	ipdList := getIPv4Data(t)

+	err := d.CreateNetwork("net1", netOptions, ipdList, nil)

 	if err != nil {

 		t.Fatalf("Failed to create bridge: %v", err)

 	}

@@ -398,7 +423,7 @@ func TestCreateLinkWithOptions(t *testing.T) {

 	epOptions := make(map[string]interface{})

 	epOptions[netlabel.MacAddress] = mac

-	te := &testEndpoint{iface: &testInterface{}}

+	te := newTestEndpoint(ipdList[0].Pool, 11)

 	err = d.CreateEndpoint("net1", "ep", te.Interface(), epOptions)

 	if err != nil {

 		t.Fatalf("Failed to create an endpoint: %s", err.Error())

@@ -458,7 +483,8 @@ func TestLinkContainers(t *testing.T) {

 	genericOption = make(map[string]interface{})

 	genericOption[netlabel.GenericData] = netconfig

-	err := d.CreateNetwork("net1", genericOption, nil, nil)

+	ipdList := getIPv4Data(t)

+	err := d.CreateNetwork("net1", genericOption, ipdList, nil)

 	if err != nil {

 		t.Fatalf("Failed to create bridge: %v", err)

 	}

@@ -467,7 +493,7 @@ func TestLinkContainers(t *testing.T) {

 	epOptions := make(map[string]interface{})

 	epOptions[netlabel.ExposedPorts] = exposedPorts

-	te1 := &testEndpoint{iface: &testInterface{}}

+	te1 := newTestEndpoint(ipdList[0].Pool, 11)

 	err = d.CreateEndpoint("net1", "ep1", te1.Interface(), epOptions)

 	if err != nil {

 		t.Fatalf("Failed to create an endpoint : %s", err.Error())

@@ -478,7 +504,7 @@ func TestLinkContainers(t *testing.T) {

 		t.Fatalf("No Ipv4 address assigned to the endpoint:  ep1")

 	}

-	te2 := &testEndpoint{iface: &testInterface{}}

+	te2 := newTestEndpoint(ipdList[0].Pool, 22)

 	err = d.CreateEndpoint("net1", "ep2", te2.Interface(), nil)

 	if err != nil {

 		t.Fatalf("Failed to create an endpoint : %s", err.Error())

@@ -581,6 +607,14 @@ func TestValidateConfig(t *testing.T) {

 	// Bridge network

 	_, network, _ := net.ParseCIDR("172.28.0.0/16")

+	c = networkConfiguration{

+		AddressIPv4: network,

+	}

+

+	err = c.Validate()

+	if err != nil {

+		t.Fatal(err)

+	}

 	// Test v4 gw

 	c.DefaultGatewayIPv4 = net.ParseIP("172.27.30.234")

@@ -596,9 +630,10 @@ func TestValidateConfig(t *testing.T) {

 	}

 	// Test v6 gw

-	_, containerSubnet, _ = net.ParseCIDR("2001:1234:ae:b004::/64")

+	_, v6nw, _ := net.ParseCIDR("2001:1234:ae:b004::/64")

 	c = networkConfiguration{

 		EnableIPv6:         true,

+		AddressIPv6:        v6nw,

 		DefaultGatewayIPv6: net.ParseIP("2001:1234:ac:b004::bad:a55"),

 	}

 	err = c.Validate()

@@ -611,6 +646,18 @@ func TestValidateConfig(t *testing.T) {

 	if err != nil {

 		t.Fatalf("Unexpected validation error on v6 default gateway")

 	}

+

+	c.AddressIPv6 = nil

+	err = c.Validate()

+	if err == nil {

+		t.Fatalf("Failed to detect invalid v6 default gateway")

+	}

+

+	c.AddressIPv6 = nil

+	err = c.Validate()

+	if err == nil {

+		t.Fatalf("Failed to detect invalid v6 default gateway")

+	}

 }

 func TestSetDefaultGw(t *testing.T) {

@@ -623,24 +670,15 @@ func TestSetDefaultGw(t *testing.T) {

 	_, subnetv6, _ := net.ParseCIDR("2001:db8:ea9:9abc:b0c4::/80")

-	var nw *net.IPNet

-	for _, n := range bridgeNetworks {

-		if err := netutils.CheckRouteOverlaps(n); err == nil {

-			nw = n

-			break

-		}

-	}

-	if nw == nil {

-		t.Skipf("Skip as no more automatic networks available")

-	}

-

-	gw4 := types.GetIPCopy(nw.IP).To4()

+	ipdList := getIPv4Data(t)

+	gw4 := types.GetIPCopy(ipdList[0].Pool.IP).To4()

 	gw4[3] = 254

 	gw6 := net.ParseIP("2001:db8:ea9:9abc:b0c4::254")

 	config := &networkConfiguration{

 		BridgeName:         DefaultBridgeName,

 		EnableIPv6:         true,

+		AddressIPv6:        subnetv6,

 		DefaultGatewayIPv4: gw4,

 		DefaultGatewayIPv6: gw6,

 	}

@@ -648,12 +686,12 @@ func TestSetDefaultGw(t *testing.T) {

 	genericOption := make(map[string]interface{})

 	genericOption[netlabel.GenericData] = config

-	err := d.CreateNetwork("dummy", genericOption, nil, nil)

+	err := d.CreateNetwork("dummy", genericOption, ipdList, nil)

 	if err != nil {

 		t.Fatalf("Failed to create bridge: %v", err)

 	}

-	te := &testEndpoint{iface: &testInterface{}}

+	te := newTestEndpoint(ipdList[0].Pool, 10)

 	err = d.CreateEndpoint("dummy", "ep", te.Interface(), nil)

 	if err != nil {

 		t.Fatalf("Failed to create endpoint: %v", err)

@@ -26,12 +26,13 @@ func TestLinkCreate(t *testing.T) {

 	genericOption := make(map[string]interface{})

 	genericOption[netlabel.GenericData] = config

-	err := d.CreateNetwork("dummy", genericOption, nil, nil)

+	ipdList := getIPv4Data(t)

+	err := d.CreateNetwork("dummy", genericOption, ipdList, nil)

 	if err != nil {

 		t.Fatalf("Failed to create bridge: %v", err)

 	}

-	te := &testEndpoint{iface: &testInterface{}}

+	te := newTestEndpoint(ipdList[0].Pool, 10)

 	err = d.CreateEndpoint("dummy", "", te.Interface(), nil)

 	if err != nil {

 		if _, ok := err.(InvalidEndpointIDError); !ok {

@@ -63,7 +64,7 @@ func TestLinkCreate(t *testing.T) {

 	// TODO: if we could get peer name from (sboxLnk.(*netlink.Veth)).PeerName

 	// then we could check the MTU on hostLnk as well.

-	te1 := &testEndpoint{iface: &testInterface{}}

+	te1 := newTestEndpoint(ipdList[0].Pool, 11)

 	err = d.CreateEndpoint("dummy", "ep", te1.Interface(), nil)

 	if err == nil {

 		t.Fatalf("Failed to detect duplicate endpoint id on same network")

@@ -117,18 +118,19 @@ func TestLinkCreateTwo(t *testing.T) {

 	genericOption := make(map[string]interface{})

 	genericOption[netlabel.GenericData] = config

-	err := d.CreateNetwork("dummy", genericOption, nil, nil)

+	ipdList := getIPv4Data(t)

+	err := d.CreateNetwork("dummy", genericOption, ipdList, nil)

 	if err != nil {

 		t.Fatalf("Failed to create bridge: %v", err)

 	}

-	te1 := &testEndpoint{iface: &testInterface{}}

+	te1 := newTestEndpoint(ipdList[0].Pool, 11)

 	err = d.CreateEndpoint("dummy", "ep", te1.Interface(), nil)

 	if err != nil {

 		t.Fatalf("Failed to create a link: %s", err.Error())

 	}

-	te2 := &testEndpoint{iface: &testInterface{}}

+	te2 := newTestEndpoint(ipdList[0].Pool, 12)

 	err = d.CreateEndpoint("dummy", "ep", te2.Interface(), nil)

 	if err != nil {

 		if _, ok := err.(driverapi.ErrEndpointExists); !ok {

@@ -152,12 +154,12 @@ func TestLinkCreateNoEnableIPv6(t *testing.T) {

 	genericOption := make(map[string]interface{})

 	genericOption[netlabel.GenericData] = config

-	err := d.CreateNetwork("dummy", genericOption, nil, nil)

+	ipdList := getIPv4Data(t)

+	err := d.CreateNetwork("dummy", genericOption, ipdList, nil)

 	if err != nil {

 		t.Fatalf("Failed to create bridge: %v", err)

 	}

-

-	te := &testEndpoint{iface: &testInterface{}}

+	te := newTestEndpoint(ipdList[0].Pool, 30)

 	err = d.CreateEndpoint("dummy", "ep", te.Interface(), nil)

 	if err != nil {

 		t.Fatalf("Failed to create a link: %s", err.Error())

@@ -187,12 +189,13 @@ func TestLinkDelete(t *testing.T) {

 	genericOption := make(map[string]interface{})

 	genericOption[netlabel.GenericData] = config

-	err := d.CreateNetwork("dummy", genericOption, nil, nil)

+	ipdList := getIPv4Data(t)

+	err := d.CreateNetwork("dummy", genericOption, ipdList, nil)

 	if err != nil {

 		t.Fatalf("Failed to create bridge: %v", err)

 	}

-	te := &testEndpoint{iface: &testInterface{}}

+	te := newTestEndpoint(ipdList[0].Pool, 30)

 	err = d.CreateEndpoint("dummy", "ep1", te.Interface(), nil)

 	if err != nil {

 		t.Fatalf("Failed to create a link: %s", err.Error())

@@ -44,12 +44,13 @@ func TestPortMappingConfig(t *testing.T) {

 	netOptions := make(map[string]interface{})

 	netOptions[netlabel.GenericData] = netConfig

-	err := d.CreateNetwork("dummy", netOptions, nil, nil)

+	ipdList := getIPv4Data(t)

+	err := d.CreateNetwork("dummy", netOptions, ipdList, nil)

 	if err != nil {

 		t.Fatalf("Failed to create bridge: %v", err)

 	}

-	te := &testEndpoint{iface: &testInterface{}}

+	te := newTestEndpoint(ipdList[0].Pool, 11)

 	err = d.CreateEndpoint("dummy", "ep1", te.Interface(), epOptions)

 	if err != nil {

 		t.Fatalf("Failed to create the endpoint: %s", err.Error())

@@ -22,7 +22,7 @@ const (

 //Gets the IP version in use ( [ipv4], [ipv6] or [ipv4 and ipv6] )

 func getIPVersion(config *networkConfiguration) ipVersion {

 	ipVersion := ipv4

-	if config.EnableIPv6 {

+	if config.AddressIPv6 != nil || config.EnableIPv6 {

 		ipVersion |= ipv6

 	}

 	return ipVersion

@@ -3,103 +3,38 @@ package bridge

 import (

 	"fmt"

 	"io/ioutil"

-	"net"

 	"path/filepath"

 	log "github.com/Sirupsen/logrus"

-	"github.com/docker/libnetwork/netutils"

+	"github.com/docker/libnetwork/types"

 	"github.com/vishvananda/netlink"

 )

-var bridgeNetworks []*net.IPNet

-

-func init() {

-	// Here we don't follow the convention of using the 1st IP of the range for the gateway.

-	// This is to use the same gateway IPs as the /24 ranges, which predate the /16 ranges.

-	// In theory this shouldn't matter - in practice there's bound to be a few scripts relying

-	// on the internal addressing or other stupid things like that.

-	// They shouldn't, but hey, let's not break them unless we really have to.

-	// Don't use 172.16.0.0/16, it conflicts with EC2 DNS 172.16.0.23

-

-	// 172.[17-31].42.1/16

-	mask := []byte{255, 255, 0, 0}

-	for i := 17; i < 32; i++ {

-		bridgeNetworks = append(bridgeNetworks, &net.IPNet{IP: []byte{172, byte(i), 42, 1}, Mask: mask})

-	}

-	// 10.[0-255].42.1/16

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

-		bridgeNetworks = append(bridgeNetworks, &net.IPNet{IP: []byte{10, byte(i), 42, 1}, Mask: mask})

-	}

-	// 192.168.[42-44].1/24

-	mask24 := []byte{255, 255, 255, 0}

-	for i := 42; i < 45; i++ {

-		bridgeNetworks = append(bridgeNetworks, &net.IPNet{IP: []byte{192, 168, byte(i), 1}, Mask: mask24})

-	}

-}

-

 func setupBridgeIPv4(config *networkConfiguration, i *bridgeInterface) error {

 	addrv4, _, err := i.addresses()

 	if err != nil {

-		return err

-	}

-

-	// Check if we have an IP address already on the bridge.

-	if addrv4.IPNet != nil {

-		// Make sure to store bridge network and default gateway before getting out.

-		i.bridgeIPv4 = addrv4.IPNet

-		i.gatewayIPv4 = addrv4.IPNet.IP

-		return nil

-	}

-

-	// Do not try to configure IPv4 on a non-default bridge unless you are

-	// specifically asked to do so.

-	if config.BridgeName != DefaultBridgeName && config.DefaultBridge {

-		return NonDefaultBridgeNeedsIPError(config.BridgeName)

-	}

-

-	bridgeIPv4, err := electBridgeIPv4(config)

-	if err != nil {

-		return err

+		return fmt.Errorf("failed to retrieve bridge interface addresses: %v", err)

 	}

-	log.Debugf("Creating bridge interface %s with network %s", config.BridgeName, bridgeIPv4)

-	if err := netlink.AddrAdd(i.Link, &netlink.Addr{IPNet: bridgeIPv4}); err != nil {

-		return &IPv4AddrAddError{IP: bridgeIPv4, Err: err}

+	if !types.CompareIPNet(addrv4.IPNet, config.AddressIPv4) {

+		if addrv4.IPNet != nil {

+			if err := netlink.AddrDel(i.Link, &addrv4); err != nil {

+				return fmt.Errorf("failed to remove current ip address from bridge: %v", err)

+			}

+		}

+		log.Debugf("Assigning address to bridge interface %s: %s", config.BridgeName, config.AddressIPv4)

+		if err := netlink.AddrAdd(i.Link, &netlink.Addr{IPNet: config.AddressIPv4}); err != nil {

+			return &IPv4AddrAddError{IP: config.AddressIPv4, Err: err}

+		}

 	}

 	// Store bridge network and default gateway

-	i.bridgeIPv4 = bridgeIPv4

-	i.gatewayIPv4 = i.bridgeIPv4.IP

+	i.bridgeIPv4 = config.AddressIPv4

+	i.gatewayIPv4 = config.AddressIPv4.IP

 	return nil

 }

-func electBridgeIPv4(config *networkConfiguration) (*net.IPNet, error) {

-	// Use the requested IPv4 CIDR when available.

-	if config.AddressIPv4 != nil {

-		return config.AddressIPv4, nil

-	}

-

-	// We don't check for an error here, because we don't really care if we

-	// can't read /etc/resolv.conf. So instead we skip the append if resolvConf

-	// is nil. It either doesn't exist, or we can't read it for some reason.

-	nameservers := []string{}

-	if resolvConf, _ := readResolvConf(); resolvConf != nil {

-		nameservers = append(nameservers, getNameserversAsCIDR(resolvConf)...)

-	}

-

-	// Try to automatically elect appropriate bridge IPv4 settings.

-	for _, n := range bridgeNetworks {

-		if err := netutils.CheckNameserverOverlaps(nameservers, n); err == nil {

-			if err := netutils.CheckRouteOverlaps(n); err == nil {

-				return n, nil

-			}

-		}

-	}

-

-	return nil, IPv4AddrRangeError(config.BridgeName)

-}

-

 func setupGatewayIPv4(config *networkConfiguration, i *bridgeInterface) error {

 	if !i.bridgeIPv4.Contains(config.DefaultGatewayIPv4) {