@@ -59,7 +59,7 @@ There are many networking solutions available to suit a broad range of use-cases

         }

 		// libentwork client can check the endpoint's operational data via the Info() API

-		epInfo, err := ep.Info()

+		epInfo, err := ep.DriverInfo()

 		mapData, ok := epInfo[netlabel.PortMap]

 		if ok {

 			portMapping, ok := mapData.([]netutils.PortBinding)

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

 	"github.com/docker/libnetwork"

 	"github.com/docker/libnetwork/netutils"

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

 	"github.com/gorilla/mux"

 )

@@ -143,7 +142,6 @@ type endpointResource struct {

 	Name    string

 	ID      string

 	Network string

-	Info    sandbox.Info

 }

 func buildNetworkResource(nw libnetwork.Network) *networkResource {

@@ -168,11 +166,6 @@ func buildEndpointResource(ep libnetwork.Endpoint) *endpointResource {

 		r.Name = ep.Name()

 		r.ID = ep.ID()

 		r.Network = ep.Network()

-

-		i := ep.SandboxInfo()

-		if i != nil {

-			r.Info = *i

-		}

 	}

 	return r

 }

@@ -430,7 +423,7 @@ func procLeaveEndpoint(c libnetwork.NetworkController, vars map[string]string, b

 		return nil, errRsp

 	}

-	err := ep.Leave(vars[urlCnID], nil)

+	err := ep.Leave(vars[urlCnID])

 	if err != nil {

 		return nil, convertNetworkError(err)

 	}

@@ -55,7 +55,7 @@ func main() {

 	}

 	// libentwork client can check the endpoint's operational data via the Info() API

-	epInfo, err := ep.Info()

+	epInfo, err := ep.DriverInfo()

 	mapData, ok := epInfo[netlabel.PortMap]

 	if ok {

 		portMapping, ok := mapData.([]netutils.PortBinding)

@@ -73,14 +73,14 @@ Consumers of the CNM, like Docker for example, interact through the CNM Objects

 3. `controller.NewNetwork()` API also takes in optional `options` parameter which carries Driver-specific options and `Labels`, which the Drivers can make use for its purpose.

-4. `network.CreateEndpoint()` can be called to create a new Endpoint in a given network. This API also accepts optional `options` parameter which drivers can make use of. These 'options' carry both well-known labels and driver-specific labels. Drivers will inturn be called with `driver.CreateEndpoint` and it can choose to reserve any required resources when an `Endpoint` is created in a `Network`. The `Driver` must return the reserved resources via the `sandbox.Info` return object. LibNetwork will make use of the `SandboxInfo` when a Container is attached later. The reason we get the `sandbox.Info` at the time of endpoint creation and not during the `Join()` is that, `Endpoint` represents a Service endpoint and not neccessarily the container that attaches later.

+4. `network.CreateEndpoint()` can be called to create a new Endpoint in a given network. This API also accepts optional `options` parameter which drivers can make use of. These 'options' carry both well-known labels and driver-specific labels. Drivers will in turn be called with `driver.CreateEndpoint` and it can choose to reserve IPv4/IPv6 addresses when an `Endpoint` is created in a `Network`. The `Driver` will assign these addresses using `InterfaceInfo` interface defined in the `driverapi`. The IP/IPv6 are needed to complete the endpoint as service definition along with the ports the endpoint exposes since essentially a service endpoint is nothing but a network address and the port number that the application container is listening on.

 5. `endpoint.Join()` can be used to attach a container to a `Endpoint`. The Join operation will create a `Sandbox` if it doesnt exist already for that container. The Drivers can make use of the Sandbox Key to identify multiple endpoints attached to a same container. This API also accepts optional `options` parameter which drivers can make use of.

   * Though it is not a direct design issue of LibNetwork, it is highly encouraged to have users like `Docker` to call the endpoint.Join() during Container's `Start()` lifecycle that is invoked *before* the container is made operational. As part of Docker integration, this will be taken care of.

   * one of a FAQ on endpoint join() API is that, why do we need an API to create an Endpoint and another to join the endpoint.

     - The answer is based on the fact that Endpoint represents a Service which may or may not be backed by a Container. When an Endpoint is created, it will have its resources reserved so that any container can get attached to the endpoint later and get a consistent networking behaviour.

-6. `endpoint.Leave()` can be invoked when a container is stopped. The `Driver` can cleanup the states that it allocated during the `Join()` call. LibNetwork will delete the `Sandbox` when the last referencing endpoint leaves the network. But LibNetwork keeps hold of the `sandbox.Info` and will be reused when the container joins again. This ensures that the container's resources are reused when they are Stopped and Started again.

+6. `endpoint.Leave()` can be invoked when a container is stopped. The `Driver` can cleanup the states that it allocated during the `Join()` call. LibNetwork will delete the `Sandbox` when the last referencing endpoint leaves the network. But LibNetwork keeps hold of the IP addresses as long as the endpoint is still present and will be reused when the container(or any container) joins again. This ensures that the container's resources are reused when they are Stopped and Started again.

 7. `endpoint.Delete()` is used to delete an endpoint from a network. This results in deleting an endpoint and cleaning up the cached `sandbox.Info`.

@@ -3,8 +3,8 @@ package driverapi

 import (

 	"errors"

 	"fmt"

+	"net"

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

 	"github.com/docker/libnetwork/types"

 )

@@ -37,32 +37,91 @@ type Driver interface {

 	DeleteNetwork(nid types.UUID) error

 	// CreateEndpoint invokes the driver method to create an endpoint

-	// passing the network id, endpoint id and driver

-	// specific config. The config mechanism will eventually be replaced

-	// with labels which are yet to be introduced.

-	CreateEndpoint(nid, eid types.UUID, options map[string]interface{}) (*sandbox.Info, error)

+	// passing the network id, endpoint id endpoint information and driver

+	// specific config. The endpoint information can be either consumed by

+	// the driver or populated by the driver. The config mechanism will

+	// eventually be replaced with labels which are yet to be introduced.

+	CreateEndpoint(nid, eid types.UUID, epInfo EndpointInfo, options map[string]interface{}) error

 	// DeleteEndpoint invokes the driver method to delete an endpoint

 	// passing the network id and endpoint id.

 	DeleteEndpoint(nid, eid types.UUID) error

-	// EndpointInfo retrieves from the driver the operational data related to the specified endpoint

-	EndpointInfo(nid, eid types.UUID) (map[string]interface{}, error)

+	// EndpointOperInfo retrieves from the driver the operational data related to the specified endpoint

+	EndpointOperInfo(nid, eid types.UUID) (map[string]interface{}, error)

 	// Join method is invoked when a Sandbox is attached to an endpoint.

-	Join(nid, eid types.UUID, sboxKey string, options map[string]interface{}) (*JoinInfo, error)

+	Join(nid, eid types.UUID, sboxKey string, jinfo JoinInfo, options map[string]interface{}) error

 	// Leave method is invoked when a Sandbox detaches from an endpoint.

-	Leave(nid, eid types.UUID, options map[string]interface{}) error

+	Leave(nid, eid types.UUID) error

 	// Type returns the the type of this driver, the network type this driver manages

 	Type() string

 }

+// EndpointInfo provides a go interface to fetch or populate endpoint assigned network resources.

+type EndpointInfo interface {

+	// Interfaces returns a list of interfaces bound to the endpoint.

+	// If the list is not empty the driver is only expected to consume the interfaces.

+	// It is an error to try to add interfaces to a non-empty list.

+	// If the list is empty the driver is expected to populate with 0 or more interfaces.

+	Interfaces() []InterfaceInfo

+

+	// AddInterface is used by the driver to add an interface to the interface list.

+	// This method will return an error if the driver attempts to add interfaces

+	// if the Interfaces() method returned a non-empty list.

+	// ID field need only have significance within the endpoint so it can be a simple

+	// monotonically increasing number

+	AddInterface(ID int, mac net.HardwareAddr, ipv4 net.IPNet, ipv6 net.IPNet) error

+}

+

+// InterfaceInfo provides a go interface for drivers to retrive

+// network information to interface resources.

+type InterfaceInfo interface {

+	// MacAddress returns the MAC address.

+	MacAddress() net.HardwareAddr

+

+	// Address returns the IPv4 address.

+	Address() net.IPNet

+

+	// AddressIPv6 returns the IPv6 address.

+	AddressIPv6() net.IPNet

+

+	// ID returns the numerical id of the interface and has significance only within

+	// the endpoint.

+	ID() int

+}

+

+// InterfaceNameInfo provides a go interface for the drivers to assign names

+// to interfaces.

+type InterfaceNameInfo interface {

+	// SetNames method assigns the srcName and dstName for the interface.

+	SetNames(srcName, dstName string) error

+

+	// ID returns the numerical id that was assigned to the interface by the driver

+	// CreateEndpoint.

+	ID() int

+}

+

 // JoinInfo represents a set of resources that the driver has the ability to provide during

 // join time.

-type JoinInfo struct {

-	HostsPath string

+type JoinInfo interface {

+	// InterfaceNames returns a list of InterfaceNameInfo go interface to facilitate

+	// setting the names for the interfaces.

+	InterfaceNames() []InterfaceNameInfo

+

+	// SetGateway sets the default IPv4 gateway when a container joins the endpoint.

+	SetGateway(net.IP) error

+

+	// SetGatewayIPv6 sets the default IPv6 gateway when a container joins the endpoint.

+	SetGatewayIPv6(net.IP) error

+

+	// SetHostsPath sets the overriding /etc/hosts path to use for the container.

+	SetHostsPath(string) error

+

+	// SetResolvConfPath sets the overriding /etc/resolv.conf path to use for the container.

+	SetResolvConfPath(string) error

 }

 // ErrActiveRegistration represents an error when a driver is registered to a networkType that is previously registered

@@ -1,6 +1,7 @@

 package bridge

 import (

+	"errors"

 	"net"

 	"strings"

 	"sync"

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

 	vethLen                 = 7

 	containerVeth           = "eth0"

 	maxAllocatePortAttempts = 10

+	ifaceID                 = 1

 )

 var (

@@ -371,44 +373,52 @@ func (d *driver) DeleteNetwork(nid types.UUID) error {

 	return err

 }

-func (d *driver) CreateEndpoint(nid, eid types.UUID, epOptions map[string]interface{}) (*sandbox.Info, error) {

+func (d *driver) CreateEndpoint(nid, eid types.UUID, epInfo driverapi.EndpointInfo, epOptions map[string]interface{}) error {

 	var (

 		ipv6Addr *net.IPNet

 		err      error

 	)

+	if epInfo == nil {

+		return errors.New("invalid endpoint info passed")

+	}

+

+	if len(epInfo.Interfaces()) != 0 {

+		return errors.New("non empty interface list passed to bridge(local) driver")

+	}

+

 	// Get the network handler and make sure it exists

 	d.Lock()

 	n := d.network

 	config := n.config

 	d.Unlock()

 	if n == nil {

-		return nil, driverapi.ErrNoNetwork

+		return driverapi.ErrNoNetwork

 	}

 	// Sanity check

 	n.Lock()

 	if n.id != nid {

 		n.Unlock()

-		return nil, InvalidNetworkIDError(nid)

+		return InvalidNetworkIDError(nid)

 	}

 	n.Unlock()

 	// Check if endpoint id is good and retrieve correspondent endpoint

 	ep, err := n.getEndpoint(eid)

 	if err != nil {

-		return nil, err

+		return err

 	}

 	// Endpoint with that id exists either on desired or other sandbox

 	if ep != nil {

-		return nil, driverapi.ErrEndpointExists

+		return driverapi.ErrEndpointExists

 	}

 	// Try to convert the options to endpoint configuration

 	epConfig, err := parseEndpointOptions(epOptions)

 	if err != nil {

-		return nil, err

+		return err

 	}

 	// Create and add the endpoint

@@ -429,13 +439,13 @@ func (d *driver) CreateEndpoint(nid, eid types.UUID, epOptions map[string]interf

 	// Generate a name for what will be the host side pipe interface

 	name1, err := generateIfaceName()

 	if err != nil {

-		return nil, err

+		return err

 	}

 	// Generate a name for what will be the sandbox side pipe interface

 	name2, err := generateIfaceName()

 	if err != nil {

-		return nil, err

+		return err

 	}

 	// Generate and add the interface pipe host <-> sandbox

@@ -443,13 +453,13 @@ func (d *driver) CreateEndpoint(nid, eid types.UUID, epOptions map[string]interf

 		LinkAttrs: netlink.LinkAttrs{Name: name1, TxQLen: 0},

 		PeerName:  name2}

 	if err = netlink.LinkAdd(veth); err != nil {

-		return nil, err

+		return err

 	}

 	// Get the host side pipe interface handler

 	host, err := netlink.LinkByName(name1)

 	if err != nil {

-		return nil, err

+		return err

 	}

 	defer func() {

 		if err != nil {

@@ -460,7 +470,7 @@ func (d *driver) CreateEndpoint(nid, eid types.UUID, epOptions map[string]interf

 	// Get the sandbox side pipe interface handler

 	sbox, err := netlink.LinkByName(name2)

 	if err != nil {

-		return nil, err

+		return err

 	}

 	defer func() {

 		if err != nil {

@@ -472,7 +482,7 @@ func (d *driver) CreateEndpoint(nid, eid types.UUID, epOptions map[string]interf

 	mac := electMacAddress(epConfig)

 	err = netlink.LinkSetHardwareAddr(sbox, mac)

 	if err != nil {

-		return nil, err

+		return err

 	}

 	endpoint.macAddress = mac

@@ -480,28 +490,29 @@ func (d *driver) CreateEndpoint(nid, eid types.UUID, epOptions map[string]interf

 	if config.Mtu != 0 {

 		err = netlink.LinkSetMTU(host, config.Mtu)

 		if err != nil {

-			return nil, err

+			return err

 		}

 		err = netlink.LinkSetMTU(sbox, config.Mtu)

 		if err != nil {

-			return nil, err

+			return err

 		}

 	}

 	// Attach host side pipe interface into the bridge

 	if err = netlink.LinkSetMaster(host,

 		&netlink.Bridge{LinkAttrs: netlink.LinkAttrs{Name: config.BridgeName}}); err != nil {

-		return nil, err

+		return err

 	}

 	// v4 address for the sandbox side pipe interface

 	ip4, err := ipAllocator.RequestIP(n.bridge.bridgeIPv4, nil)

 	if err != nil {

-		return nil, err

+		return err

 	}

 	ipv4Addr := &net.IPNet{IP: ip4, Mask: n.bridge.bridgeIPv4.Mask}

 	// v6 address for the sandbox side pipe interface

+	ipv6Addr = &net.IPNet{}

 	if config.EnableIPv6 {

 		var ip6 net.IP

@@ -521,7 +532,7 @@ func (d *driver) CreateEndpoint(nid, eid types.UUID, epOptions map[string]interf

 		ip6, err := ipAllocator.RequestIP(network, ip6)

 		if err != nil {

-			return nil, err

+			return err

 		}

 		ipv6Addr = &net.IPNet{IP: ip6, Mask: network.Mask}

@@ -533,26 +544,25 @@ func (d *driver) CreateEndpoint(nid, eid types.UUID, epOptions map[string]interf

 	intf.DstName = containerVeth

 	intf.Address = ipv4Addr

+	if config.EnableIPv6 {

+		intf.AddressIPv6 = ipv6Addr

+	}

+

 	// Store the interface in endpoint, this is needed for cleanup on DeleteEndpoint()

 	endpoint.intf = intf

-	// Generate the sandbox info to return

-	sinfo := &sandbox.Info{Interfaces: []*sandbox.Interface{intf}}

-

-	// Set the default gateway(s) for the sandbox

-	sinfo.Gateway = n.bridge.gatewayIPv4

-	if config.EnableIPv6 {

-		intf.AddressIPv6 = ipv6Addr

-		sinfo.GatewayIPv6 = n.bridge.gatewayIPv6

+	err = epInfo.AddInterface(ifaceID, endpoint.macAddress, *ipv4Addr, *ipv6Addr)

+	if err != nil {

+		return err

 	}

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

-	endpoint.portMapping, err = allocatePorts(epConfig, sinfo, config.DefaultBindingIP)

+	endpoint.portMapping, err = allocatePorts(epConfig, intf, config.DefaultBindingIP)

 	if err != nil {

-		return nil, err

+		return err

 	}

-	return sinfo, nil

+	return nil

 }

 func (d *driver) DeleteEndpoint(nid, eid types.UUID) error {

@@ -628,7 +638,7 @@ func (d *driver) DeleteEndpoint(nid, eid types.UUID) error {

 	return nil

 }

-func (d *driver) EndpointInfo(nid, eid types.UUID) (map[string]interface{}, error) {

+func (d *driver) EndpointOperInfo(nid, eid types.UUID) (map[string]interface{}, error) {

 	// Get the network handler and make sure it exists

 	d.Lock()

 	n := d.network

@@ -673,40 +683,55 @@ func (d *driver) EndpointInfo(nid, eid types.UUID) (map[string]interface{}, erro

 }

 // Join method is invoked when a Sandbox is attached to an endpoint.

-func (d *driver) Join(nid, eid types.UUID, sboxKey string, options map[string]interface{}) (*driverapi.JoinInfo, error) {

+func (d *driver) Join(nid, eid types.UUID, sboxKey string, jinfo driverapi.JoinInfo, options map[string]interface{}) error {

 	network, err := d.getNetwork(nid)

 	if err != nil {

-		return nil, err

+		return err

 	}

-	if !network.config.EnableICC {

-		return nil, d.link(nid, eid, options, true)

+	endpoint, err := network.getEndpoint(eid)

+	if err != nil {

+		return err

 	}

-	return nil, nil

-}

+	if endpoint == nil {

+		return EndpointNotFoundError(eid)

+	}

-// Leave method is invoked when a Sandbox detaches from an endpoint.

-func (d *driver) Leave(nid, eid types.UUID, options map[string]interface{}) error {

-	network, err := d.getNetwork(nid)

+	for _, iNames := range jinfo.InterfaceNames() {

+		// Make sure to set names on the correct interface ID.

+		if iNames.ID() == ifaceID {

+			err = iNames.SetNames(endpoint.intf.SrcName, endpoint.intf.DstName)

+			if err != nil {

+				return err

+			}

+		}

+	}

+

+	err = jinfo.SetGateway(network.bridge.gatewayIPv4)

+	if err != nil {

+		return err

+	}

+

+	err = jinfo.SetGatewayIPv6(network.bridge.gatewayIPv6)

 	if err != nil {

 		return err

 	}

 	if !network.config.EnableICC {

-		return d.link(nid, eid, options, false)

+		return d.link(network, endpoint, options, true)

 	}

 	return nil

 }

-func (d *driver) link(nid, eid types.UUID, options map[string]interface{}, enable bool) error {

-	var cc *ContainerConfiguration

-

+// Leave method is invoked when a Sandbox detaches from an endpoint.

+func (d *driver) Leave(nid, eid types.UUID) error {

 	network, err := d.getNetwork(nid)

 	if err != nil {

 		return err

 	}

+

 	endpoint, err := network.getEndpoint(eid)

 	if err != nil {

 		return err

@@ -716,6 +741,19 @@ func (d *driver) link(nid, eid types.UUID, options map[string]interface{}, enabl

 		return EndpointNotFoundError(eid)

 	}

+	if !network.config.EnableICC {

+		return d.link(network, endpoint, nil, false)

+	}

+

+	return nil

+}

+

+func (d *driver) link(network *bridgeNetwork, endpoint *bridgeEndpoint, options map[string]interface{}, enable bool) error {

+	var (

+		cc  *ContainerConfiguration

+		err error

+	)

+

 	if enable {

 		cc, err = parseContainerOptions(options)

 		if err != nil {

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

 	"regexp"

 	"testing"

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

 	"github.com/docker/libnetwork/iptables"

 	"github.com/docker/libnetwork/netlabel"

 	"github.com/docker/libnetwork/netutils"

@@ -70,6 +71,91 @@ func TestCreateFail(t *testing.T) {

 	}

 }

+type testInterface struct {

+	id      int

+	mac     net.HardwareAddr

+	addr    net.IPNet

+	addrv6  net.IPNet

+	srcName string

+	dstName string

+}

+

+type testEndpoint struct {

+	ifaces         []*testInterface

+	gw             net.IP

+	gw6            net.IP

+	hostsPath      string

+	resolvConfPath string

+}

+

+func (te *testEndpoint) Interfaces() []driverapi.InterfaceInfo {

+	iList := make([]driverapi.InterfaceInfo, len(te.ifaces))

+

+	for i, iface := range te.ifaces {

+		iList[i] = iface

+	}

+

+	return iList

+}

+

+func (te *testEndpoint) AddInterface(id int, mac net.HardwareAddr, ipv4 net.IPNet, ipv6 net.IPNet) error {

+	iface := &testInterface{id: id, addr: ipv4, addrv6: ipv6}

+	te.ifaces = append(te.ifaces, iface)

+	return nil

+}

+

+func (i *testInterface) ID() int {

+	return i.id

+}

+

+func (i *testInterface) MacAddress() net.HardwareAddr {

+	return i.mac

+}

+

+func (i *testInterface) Address() net.IPNet {

+	return i.addr

+}

+

+func (i *testInterface) AddressIPv6() net.IPNet {

+	return i.addrv6

+}

+

+func (i *testInterface) SetNames(srcName string, dstName string) error {

+	i.srcName = srcName

+	i.dstName = dstName

+	return nil

+}

+

+func (te *testEndpoint) InterfaceNames() []driverapi.InterfaceNameInfo {

+	iList := make([]driverapi.InterfaceNameInfo, len(te.ifaces))

+

+	for i, iface := range te.ifaces {

+		iList[i] = iface

+	}

+

+	return iList

+}

+

+func (te *testEndpoint) SetGateway(gw net.IP) error {

+	te.gw = gw

+	return nil

+}

+

+func (te *testEndpoint) SetGatewayIPv6(gw6 net.IP) error {

+	te.gw6 = gw6

+	return nil

+}

+

+func (te *testEndpoint) SetHostsPath(path string) error {

+	te.hostsPath = path

+	return nil

+}

+

+func (te *testEndpoint) SetResolvConfPath(path string) error {

+	te.resolvConfPath = path

+	return nil

+}

+

 func TestQueryEndpointInfo(t *testing.T) {

 	defer netutils.SetupTestNetNS(t)()

 	d := newDriver()

@@ -92,13 +178,14 @@ func TestQueryEndpointInfo(t *testing.T) {

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

 	epOptions[netlabel.PortMap] = portMappings

-	_, err = d.CreateEndpoint("net1", "ep1", epOptions)

+	te := &testEndpoint{ifaces: []*testInterface{}}

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

 	if err != nil {

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

 	}

 	ep, _ := dd.network.endpoints["ep1"]

-	data, err := d.EndpointInfo(dd.network.id, ep.id)

+	data, err := d.EndpointOperInfo(dd.network.id, ep.id)

 	if err != nil {

 		t.Fatalf("Failed to ask for endpoint operational data:  %v", err)

 	}

@@ -143,12 +230,18 @@ func TestCreateLinkWithOptions(t *testing.T) {

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

 	epOptions[netlabel.MacAddress] = mac

-	sinfo, err := d.CreateEndpoint("net1", "ep", epOptions)

+	te := &testEndpoint{ifaces: []*testInterface{}}

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

+	if err != nil {

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

+	}

+

+	err = d.Join("net1", "ep", "sbox", te, nil)

 	if err != nil {

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

+		t.Fatalf("Failed to join the endpoint: %v", err)

 	}

-	ifaceName := sinfo.Interfaces[0].SrcName

+	ifaceName := te.ifaces[0].srcName

 	veth, err := netlink.LinkByName(ifaceName)

 	if err != nil {

 		t.Fatal(err)

@@ -197,23 +290,25 @@ func TestLinkContainers(t *testing.T) {

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

 	epOptions[netlabel.ExposedPorts] = exposedPorts

-	sinfo, err := d.CreateEndpoint("net1", "ep1", epOptions)

+	te1 := &testEndpoint{ifaces: []*testInterface{}}

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

 	if err != nil {

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

 	}

-	addr1 := sinfo.Interfaces[0].Address

-	if addr1 == nil {

+	addr1 := te1.ifaces[0].addr

+	if addr1.IP.To4() == nil {

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

 	}

-	sinfo, err = d.CreateEndpoint("net1", "ep2", nil)

+	te2 := &testEndpoint{ifaces: []*testInterface{}}

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

 	if err != nil {

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

 	}

-	addr2 := sinfo.Interfaces[0].Address

-	if addr2 == nil {

+	addr2 := te2.ifaces[0].addr

+	if addr2.IP.To4() == nil {

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

 	}

@@ -222,7 +317,7 @@ func TestLinkContainers(t *testing.T) {

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

 	genericOption[netlabel.GenericData] = cConfig

-	_, err = d.Join("net1", "ep2", "", genericOption)

+	err = d.Join("net1", "ep2", "", te2, genericOption)

 	if err != nil {

 		t.Fatalf("Failed to link ep1 and ep2")

 	}

@@ -243,7 +338,7 @@ func TestLinkContainers(t *testing.T) {

 		}

 	}

-	err = d.Leave("net1", "ep2", genericOption)

+	err = d.Leave("net1", "ep2")

 	if err != nil {

 		t.Fatalf("Failed to unlink ep1 and ep2")

 	}

@@ -270,7 +365,7 @@ func TestLinkContainers(t *testing.T) {

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

 	genericOption[netlabel.GenericData] = cConfig

-	_, err = d.Join("net1", "ep2", "", genericOption)

+	err = d.Join("net1", "ep2", "", te2, genericOption)

 	if err != nil {

 		out, err = iptables.Raw("-L", DockerChain)

 		for _, pm := range exposedPorts {

@@ -406,16 +501,22 @@ func TestSetDefaultGw(t *testing.T) {

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

 	}

-	sinfo, err := d.CreateEndpoint("dummy", "ep", nil)

+	te := &testEndpoint{ifaces: []*testInterface{}}

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

 	if err != nil {

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

 	}

-	if !gw4.Equal(sinfo.Gateway) {

-		t.Fatalf("Failed to configure default gateway. Expected %v. Found %v", gw4, sinfo.Gateway)

+	err = d.Join("dummy", "ep", "sbox", te, nil)

+	if err != nil {

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

+	}

+

+	if !gw4.Equal(te.gw) {

+		t.Fatalf("Failed to configure default gateway. Expected %v. Found %v", gw4, te.gw)

 	}

-	if !gw6.Equal(sinfo.GatewayIPv6) {

-		t.Fatalf("Failed to configure default gateway. Expected %v. Found %v", gw6, sinfo.GatewayIPv6)

+	if !gw6.Equal(te.gw6) {

+		t.Fatalf("Failed to configure default gateway. Expected %v. Found %v", gw6, te.gw6)

 	}

 }

@@ -28,7 +28,8 @@ func TestLinkCreate(t *testing.T) {

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

 	}

-	sinfo, err := d.CreateEndpoint("dummy", "", nil)

+	te := &testEndpoint{ifaces: []*testInterface{}}

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

 	if err != nil {

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

 			t.Fatalf("Failed with a wrong error :%s", err.Error())

@@ -38,13 +39,18 @@ func TestLinkCreate(t *testing.T) {

 	}

 	// Good endpoint creation

-	sinfo, err = d.CreateEndpoint("dummy", "ep", nil)

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

+	if err != nil {

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

+	}

+

+	err = d.Join("dummy", "ep", "sbox", te, nil)

 	if err != nil {

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

 	}

 	// Verify sbox endoint interface inherited MTU value from bridge config

-	sboxLnk, err := netlink.LinkByName(sinfo.Interfaces[0].SrcName)

+	sboxLnk, err := netlink.LinkByName(te.ifaces[0].srcName)

 	if err != nil {

 		t.Fatal(err)

 	}

@@ -54,44 +60,44 @@ 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.

-	_, err = d.CreateEndpoint("dummy", "ep", nil)

+	te1 := &testEndpoint{ifaces: []*testInterface{}}

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

 	if err == nil {

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

 	}

-	interfaces := sinfo.Interfaces

-	if len(interfaces) != 1 {

-		t.Fatalf("Expected exactly one interface. Instead got %d interface(s)", len(interfaces))

+	if len(te.ifaces) != 1 {

+		t.Fatalf("Expected exactly one interface. Instead got %d interface(s)", len(te.ifaces))

 	}

-	if interfaces[0].DstName == "" {

+	if te.ifaces[0].dstName == "" {

 		t.Fatal("Invalid Dstname returned")

 	}

-	_, err = netlink.LinkByName(interfaces[0].SrcName)

+	_, err = netlink.LinkByName(te.ifaces[0].srcName)

 	if err != nil {

-		t.Fatalf("Could not find source link %s: %v", interfaces[0].SrcName, err)

+		t.Fatalf("Could not find source link %s: %v", te.ifaces[0].srcName, err)

 	}

 	n := dr.network

-	ip := interfaces[0].Address.IP

+	ip := te.ifaces[0].addr.IP

 	if !n.bridge.bridgeIPv4.Contains(ip) {

 		t.Fatalf("IP %s is not a valid ip in the subnet %s", ip.String(), n.bridge.bridgeIPv4.String())

 	}

-	ip6 := interfaces[0].AddressIPv6.IP

+	ip6 := te.ifaces[0].addrv6.IP

 	if !n.bridge.bridgeIPv6.Contains(ip6) {

 		t.Fatalf("IP %s is not a valid ip in the subnet %s", ip6.String(), bridgeIPv6.String())

 	}

-	if !sinfo.Gateway.Equal(n.bridge.bridgeIPv4.IP) {

+	if !te.gw.Equal(n.bridge.bridgeIPv4.IP) {

 		t.Fatalf("Invalid default gateway. Expected %s. Got %s", n.bridge.bridgeIPv4.IP.String(),

-			sinfo.Gateway.String())

+			te.gw.String())

 	}

-	if !sinfo.GatewayIPv6.Equal(n.bridge.bridgeIPv6.IP) {

+	if !te.gw6.Equal(n.bridge.bridgeIPv6.IP) {

 		t.Fatalf("Invalid default gateway for IPv6. Expected %s. Got %s", n.bridge.bridgeIPv6.IP.String(),

-			sinfo.GatewayIPv6.String())

+			te.gw6.String())

 	}

 }

@@ -110,12 +116,14 @@ func TestLinkCreateTwo(t *testing.T) {

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

 	}

-	_, err = d.CreateEndpoint("dummy", "ep", nil)

+	te1 := &testEndpoint{ifaces: []*testInterface{}}

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

 	if err != nil {

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

 	}

-	_, err = d.CreateEndpoint("dummy", "ep", nil)

+	te2 := &testEndpoint{ifaces: []*testInterface{}}

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

 	if err != nil {

 		if err != driverapi.ErrEndpointExists {

 			t.Fatalf("Failed with a wrong error :%s", err.Error())

@@ -139,18 +147,19 @@ func TestLinkCreateNoEnableIPv6(t *testing.T) {

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

 	}

-	sinfo, err := d.CreateEndpoint("dummy", "ep", nil)

+	te := &testEndpoint{ifaces: []*testInterface{}}

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

 	if err != nil {

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

 	}

-	interfaces := sinfo.Interfaces

-	if interfaces[0].AddressIPv6 != nil {

-		t.Fatalf("Expectd IPv6 address to be nil when IPv6 is not enabled. Got IPv6 = %s", interfaces[0].AddressIPv6.String())

+	interfaces := te.ifaces

+	if interfaces[0].addrv6.IP.To16() != nil {

+		t.Fatalf("Expectd IPv6 address to be nil when IPv6 is not enabled. Got IPv6 = %s", interfaces[0].addrv6.String())

 	}

-	if sinfo.GatewayIPv6 != nil {

-		t.Fatalf("Expected GatewayIPv6 to be nil when IPv6 is not enabled. Got GatewayIPv6 = %s", sinfo.GatewayIPv6.String())

+	if te.gw6.To16() != nil {

+		t.Fatalf("Expected GatewayIPv6 to be nil when IPv6 is not enabled. Got GatewayIPv6 = %s", te.gw6.String())

 	}

 }

@@ -169,7 +178,8 @@ func TestLinkDelete(t *testing.T) {

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

 	}

-	_, err = d.CreateEndpoint("dummy", "ep1", nil)

+	te := &testEndpoint{ifaces: []*testInterface{}}

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

 	if err != nil {

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

 	}

@@ -187,9 +197,4 @@ func TestLinkDelete(t *testing.T) {

 	if err != nil {

 		t.Fatal(err)

 	}

-

-	err = d.DeleteEndpoint("dummy", "ep1")

-	if err == nil {

-		t.Fatal(err)

-	}

 }

@@ -15,7 +15,7 @@ var (

 	defaultBindingIP = net.IPv4(0, 0, 0, 0)

 )

-func allocatePorts(epConfig *EndpointConfiguration, sinfo *sandbox.Info, reqDefBindIP net.IP) ([]netutils.PortBinding, error) {

+func allocatePorts(epConfig *EndpointConfiguration, intf *sandbox.Interface, reqDefBindIP net.IP) ([]netutils.PortBinding, error) {

 	if epConfig == nil || epConfig.PortBindings == nil {

 		return nil, nil

 	}

@@ -25,7 +25,7 @@ func allocatePorts(epConfig *EndpointConfiguration, sinfo *sandbox.Info, reqDefB

 		defHostIP = reqDefBindIP

 	}