Remove dependency on libcontainer

Signed-off-by: Alexander Morozov <lk4d4@docker.com>

libnetwork/Godeps/Godeps.json

@@ -130,10 +130,6 @@
 			"ImportPath": "github.com/stretchr/testify/mock",
 			"Rev": "dab07ac62d4905d3e48d17dc549c684ac3b7c15a"
 		},
-		{
-			"ImportPath": "github.com/vishvananda/netlink",
-			"Rev": "20397a138846e4d6590e01783ed023ed7e1c38a6"
-		},
 		{
 			"ImportPath": "github.com/vishvananda/netns",
 			"Rev": "493029407eeb434d0c2d44e02ea072ff2488d322"

libnetwork/Godeps/_workspace/src/github.com/docker/libcontainer/netlink/MAINTAINERS

@@ -1,2 +0,0 @@
-Michael Crosby <michael@crosbymichael.com> (@crosbymichael)
-Guillaume J. Charmes <guillaume@docker.com> (@creack)

libnetwork/Godeps/_workspace/src/github.com/docker/libcontainer/netlink/netlink.go

@@ -1,31 +0,0 @@
-// Packet netlink provide access to low level Netlink sockets and messages.
-//
-// Actual implementations are in:
-// netlink_linux.go
-// netlink_darwin.go
-package netlink
-
-import (
-	"errors"
-	"net"
-)
-
-var (
-	ErrWrongSockType   = errors.New("Wrong socket type")
-	ErrShortResponse   = errors.New("Got short response from netlink")
-	ErrInterfaceExists = errors.New("Network interface already exists")
-)
-
-// A Route is a subnet associated with the interface to reach it.
-type Route struct {
-	*net.IPNet
-	Iface   *net.Interface
-	Default bool
-}
-
-// An IfAddr defines IP network settings for a given network interface
-type IfAddr struct {
-	Iface *net.Interface
-	IP    net.IP
-	IPNet *net.IPNet
-}

libnetwork/Godeps/_workspace/src/github.com/docker/libcontainer/netlink/netlink_linux_test.go

@@ -1,408 +0,0 @@
-package netlink
-
-import (
-	"net"
-	"strings"
-	"syscall"
-	"testing"
-)
-
-type testLink struct {
-	name     string
-	linkType string
-}
-
-func addLink(t *testing.T, name string, linkType string) {
-	if err := NetworkLinkAdd(name, linkType); err != nil {
-		t.Fatalf("Unable to create %s link: %s", name, err)
-	}
-}
-
-func readLink(t *testing.T, name string) *net.Interface {
-	iface, err := net.InterfaceByName(name)
-	if err != nil {
-		t.Fatalf("Could not find %s interface: %s", name, err)
-	}
-
-	return iface
-}
-
-func deleteLink(t *testing.T, name string) {
-	if err := NetworkLinkDel(name); err != nil {
-		t.Fatalf("Unable to delete %s link: %s", name, err)
-	}
-}
-
-func upLink(t *testing.T, name string) {
-	iface := readLink(t, name)
-	if err := NetworkLinkUp(iface); err != nil {
-		t.Fatalf("Could not bring UP %#v interface: %s", iface, err)
-	}
-}
-
-func downLink(t *testing.T, name string) {
-	iface := readLink(t, name)
-	if err := NetworkLinkDown(iface); err != nil {
-		t.Fatalf("Could not bring DOWN %#v interface: %s", iface, err)
-	}
-}
-
-func ipAssigned(iface *net.Interface, ip net.IP) bool {
-	addrs, _ := iface.Addrs()
-
-	for _, addr := range addrs {
-		args := strings.SplitN(addr.String(), "/", 2)
-		if args[0] == ip.String() {
-			return true
-		}
-	}
-
-	return false
-}
-
-func TestNetworkLinkAddDel(t *testing.T) {
-	if testing.Short() {
-		return
-	}
-
-	testLinks := []testLink{
-		{"tstEth", "dummy"},
-		{"tstBr", "bridge"},
-	}
-
-	for _, tl := range testLinks {
-		addLink(t, tl.name, tl.linkType)
-		defer deleteLink(t, tl.name)
-		readLink(t, tl.name)
-	}
-}
-
-func TestNetworkLinkUpDown(t *testing.T) {
-	if testing.Short() {
-		return
-	}
-
-	tl := testLink{name: "tstEth", linkType: "dummy"}
-
-	addLink(t, tl.name, tl.linkType)
-	defer deleteLink(t, tl.name)
-
-	upLink(t, tl.name)
-	ifcAfterUp := readLink(t, tl.name)
-
-	if (ifcAfterUp.Flags & syscall.IFF_UP) != syscall.IFF_UP {
-		t.Fatalf("Could not bring UP %#v initerface", tl)
-	}
-
-	downLink(t, tl.name)
-	ifcAfterDown := readLink(t, tl.name)
-
-	if (ifcAfterDown.Flags & syscall.IFF_UP) == syscall.IFF_UP {
-		t.Fatalf("Could not bring DOWN %#v initerface", tl)
-	}
-}
-
-func TestNetworkSetMacAddress(t *testing.T) {
-	if testing.Short() {
-		return
-	}
-
-	tl := testLink{name: "tstEth", linkType: "dummy"}
-	macaddr := "22:ce:e0:99:63:6f"
-
-	addLink(t, tl.name, tl.linkType)
-	defer deleteLink(t, tl.name)
-
-	ifcBeforeSet := readLink(t, tl.name)
-
-	if err := NetworkSetMacAddress(ifcBeforeSet, macaddr); err != nil {
-		t.Fatalf("Could not set %s MAC address on %#v interface: %s", macaddr, tl, err)
-	}
-
-	ifcAfterSet := readLink(t, tl.name)
-
-	if ifcAfterSet.HardwareAddr.String() != macaddr {
-		t.Fatalf("Could not set %s MAC address on %#v interface", macaddr, tl)
-	}
-}
-
-func TestNetworkSetMTU(t *testing.T) {
-	if testing.Short() {
-		return
-	}
-
-	tl := testLink{name: "tstEth", linkType: "dummy"}
-	mtu := 1400
-
-	addLink(t, tl.name, tl.linkType)
-	defer deleteLink(t, tl.name)
-
-	ifcBeforeSet := readLink(t, tl.name)
-
-	if err := NetworkSetMTU(ifcBeforeSet, mtu); err != nil {
-		t.Fatalf("Could not set %d MTU on %#v interface: %s", mtu, tl, err)
-	}
-
-	ifcAfterSet := readLink(t, tl.name)
-
-	if ifcAfterSet.MTU != mtu {
-		t.Fatalf("Could not set %d MTU on %#v interface", mtu, tl)
-	}
-}
-
-func TestNetworkSetMasterNoMaster(t *testing.T) {
-	if testing.Short() {
-		return
-	}
-
-	master := testLink{"tstBr", "bridge"}
-	slave := testLink{"tstEth", "dummy"}
-	testLinks := []testLink{master, slave}
-
-	for _, tl := range testLinks {
-		addLink(t, tl.name, tl.linkType)
-		defer deleteLink(t, tl.name)
-		upLink(t, tl.name)
-	}
-
-	masterIfc := readLink(t, master.name)
-	slaveIfc := readLink(t, slave.name)
-	if err := NetworkSetMaster(slaveIfc, masterIfc); err != nil {
-		t.Fatalf("Could not set %#v to be the master of %#v: %s", master, slave, err)
-	}
-
-	// Trying to figure out a way to test which will not break on RHEL6.
-	// We could check for existence of /sys/class/net/tstEth/upper_tstBr
-	// which should point to the ../tstBr which is the UPPER device i.e. network bridge
-
-	if err := NetworkSetNoMaster(slaveIfc); err != nil {
-		t.Fatalf("Could not UNset %#v master of %#v: %s", master, slave, err)
-	}
-}
-
-func TestNetworkChangeName(t *testing.T) {
-	if testing.Short() {
-		return
-	}
-
-	tl := testLink{"tstEth", "dummy"}
-	newName := "newTst"
-
-	addLink(t, tl.name, tl.linkType)
-
-	linkIfc := readLink(t, tl.name)
-	if err := NetworkChangeName(linkIfc, newName); err != nil {
-		deleteLink(t, tl.name)
-		t.Fatalf("Could not change %#v interface name to %s: %s", tl, newName, err)
-	}
-
-	readLink(t, newName)
-	deleteLink(t, newName)
-}
-
-func TestNetworkLinkAddVlan(t *testing.T) {
-	if testing.Short() {
-		return
-	}
-
-	tl := struct {
-		name string
-		id   uint16
-	}{
-		name: "tstVlan",
-		id:   32,
-	}
-	masterLink := testLink{"tstEth", "dummy"}
-
-	addLink(t, masterLink.name, masterLink.linkType)
-	defer deleteLink(t, masterLink.name)
-
-	if err := NetworkLinkAddVlan(masterLink.name, tl.name, tl.id); err != nil {
-		t.Fatalf("Unable to create %#v VLAN interface: %s", tl, err)
-	}
-
-	readLink(t, tl.name)
-}
-
-func TestNetworkLinkAddMacVlan(t *testing.T) {
-	if testing.Short() {
-		return
-	}
-
-	tl := struct {
-		name string
-		mode string
-	}{
-		name: "tstVlan",
-		mode: "private",
-	}
-	masterLink := testLink{"tstEth", "dummy"}
-
-	addLink(t, masterLink.name, masterLink.linkType)
-	defer deleteLink(t, masterLink.name)
-
-	if err := NetworkLinkAddMacVlan(masterLink.name, tl.name, tl.mode); err != nil {
-		t.Fatalf("Unable to create %#v MAC VLAN interface: %s", tl, err)
-	}
-
-	readLink(t, tl.name)
-}
-
-func TestNetworkLinkAddMacVtap(t *testing.T) {
-	if testing.Short() {
-		return
-	}
-
-	tl := struct {
-		name string
-		mode string
-	}{
-		name: "tstVtap",
-		mode: "private",
-	}
-	masterLink := testLink{"tstEth", "dummy"}
-
-	addLink(t, masterLink.name, masterLink.linkType)
-	defer deleteLink(t, masterLink.name)
-
-	if err := NetworkLinkAddMacVtap(masterLink.name, tl.name, tl.mode); err != nil {
-		t.Fatalf("Unable to create %#v MAC VTAP interface: %s", tl, err)
-	}
-
-	readLink(t, tl.name)
-}
-
-func TestAddDelNetworkIp(t *testing.T) {
-	if testing.Short() {
-		return
-	}
-
-	ifaceName := "lo"
-	ip := net.ParseIP("127.0.1.1")
-	mask := net.IPv4Mask(255, 255, 255, 255)
-	ipNet := &net.IPNet{IP: ip, Mask: mask}
-
-	iface, err := net.InterfaceByName(ifaceName)
-	if err != nil {
-		t.Skip("No 'lo' interface; skipping tests")
-	}
-
-	if err := NetworkLinkAddIp(iface, ip, ipNet); err != nil {
-		t.Fatalf("Could not add IP address %s to interface %#v: %s", ip.String(), iface, err)
-	}
-
-	if !ipAssigned(iface, ip) {
-		t.Fatalf("Could not locate address '%s' in lo address list.", ip.String())
-	}
-
-	if err := NetworkLinkDelIp(iface, ip, ipNet); err != nil {
-		t.Fatalf("Could not delete IP address %s from interface %#v: %s", ip.String(), iface, err)
-	}
-
-	if ipAssigned(iface, ip) {
-		t.Fatalf("Located address '%s' in lo address list after removal.", ip.String())
-	}
-}
-
-func TestAddRouteSourceSelection(t *testing.T) {
-	tstIp := "127.1.1.1"
-	tl := testLink{name: "tstEth", linkType: "dummy"}
-
-	addLink(t, tl.name, tl.linkType)
-	defer deleteLink(t, tl.name)
-
-	ip := net.ParseIP(tstIp)
-	mask := net.IPv4Mask(255, 255, 255, 255)
-	ipNet := &net.IPNet{IP: ip, Mask: mask}
-
-	iface, err := net.InterfaceByName(tl.name)
-	if err != nil {
-		t.Fatalf("Lost created link %#v", tl)
-	}
-
-	if err := NetworkLinkAddIp(iface, ip, ipNet); err != nil {
-		t.Fatalf("Could not add IP address %s to interface %#v: %s", ip.String(), iface, err)
-	}
-
-	upLink(t, tl.name)
-	defer downLink(t, tl.name)
-
-	if err := AddRoute("127.0.0.0/8", tstIp, "", tl.name); err != nil {
-		t.Fatalf("Failed to add route with source address")
-	}
-}
-
-func TestCreateVethPair(t *testing.T) {
-	if testing.Short() {
-		return
-	}
-
-	var (
-		name1 = "veth1"
-		name2 = "veth2"
-	)
-
-	if err := NetworkCreateVethPair(name1, name2, 0); err != nil {
-		t.Fatalf("Could not create veth pair %s %s: %s", name1, name2, err)
-	}
-	defer NetworkLinkDel(name1)
-
-	readLink(t, name1)
-	readLink(t, name2)
-}
-
-//
-// netlink package tests which do not use RTNETLINK
-//
-func TestCreateBridgeWithMac(t *testing.T) {
-	if testing.Short() {
-		return
-	}
-
-	name := "testbridge"
-
-	if err := CreateBridge(name, true); err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err := net.InterfaceByName(name); err != nil {
-		t.Fatal(err)
-	}
-
-	// cleanup and tests
-
-	if err := DeleteBridge(name); err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err := net.InterfaceByName(name); err == nil {
-		t.Fatalf("expected error getting interface because %s bridge was deleted", name)
-	}
-}
-
-func TestSetMacAddress(t *testing.T) {
-	if testing.Short() {
-		return
-	}
-
-	name := "testmac"
-	mac := randMacAddr()
-
-	if err := NetworkLinkAdd(name, "bridge"); err != nil {
-		t.Fatal(err)
-	}
-	defer NetworkLinkDel(name)
-
-	if err := SetMacAddress(name, mac); err != nil {
-		t.Fatal(err)
-	}
-
-	iface, err := net.InterfaceByName(name)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if iface.HardwareAddr.String() != mac {
-		t.Fatalf("mac address %q does not match %q", iface.HardwareAddr, mac)
-	}
-}

libnetwork/Godeps/_workspace/src/github.com/docker/libcontainer/netlink/netlink_unsupported.go

@@ -1,88 +0,0 @@
-// +build !linux
-
-package netlink
-
-import (
-	"errors"
-	"net"
-)
-
-var (
-	ErrNotImplemented = errors.New("not implemented")
-)
-
-func NetworkGetRoutes() ([]Route, error) {
-	return nil, ErrNotImplemented
-}
-
-func NetworkLinkAdd(name string, linkType string) error {
-	return ErrNotImplemented
-}
-
-func NetworkLinkDel(name string) error {
-	return ErrNotImplemented
-}
-
-func NetworkLinkUp(iface *net.Interface) error {
-	return ErrNotImplemented
-}
-
-func NetworkLinkAddIp(iface *net.Interface, ip net.IP, ipNet *net.IPNet) error {
-	return ErrNotImplemented
-}
-
-func NetworkLinkDelIp(iface *net.Interface, ip net.IP, ipNet *net.IPNet) error {
-	return ErrNotImplemented
-}
-
-func AddRoute(destination, source, gateway, device string) error {
-	return ErrNotImplemented
-}
-
-func AddDefaultGw(ip, device string) error {
-	return ErrNotImplemented
-}
-
-func NetworkSetMTU(iface *net.Interface, mtu int) error {
-	return ErrNotImplemented
-}
-
-func NetworkSetTxQueueLen(iface *net.Interface, txQueueLen int) error {
-	return ErrNotImplemented
-}
-
-func NetworkCreateVethPair(name1, name2 string, txQueueLen int) error {
-	return ErrNotImplemented
-}
-
-func NetworkChangeName(iface *net.Interface, newName string) error {
-	return ErrNotImplemented
-}
-
-func NetworkSetNsFd(iface *net.Interface, fd int) error {
-	return ErrNotImplemented
-}
-
-func NetworkSetNsPid(iface *net.Interface, nspid int) error {
-	return ErrNotImplemented
-}
-
-func NetworkSetMaster(iface, master *net.Interface) error {
-	return ErrNotImplemented
-}
-
-func NetworkLinkDown(iface *net.Interface) error {
-	return ErrNotImplemented
-}
-
-func CreateBridge(name string, setMacAddr bool) error {
-	return ErrNotImplemented
-}
-
-func DeleteBridge(name string) error {
-	return ErrNotImplemented
-}
-
-func AddToBridge(iface, master *net.Interface) error {
-	return ErrNotImplemented
-}

libnetwork/drivers/bridge/bridge.go

@@ -9,7 +9,6 @@ import (
 	"sync"
 
 	"github.com/Sirupsen/logrus"
-	bri "github.com/docker/libcontainer/netlink"
 	"github.com/docker/libnetwork/driverapi"
 	"github.com/docker/libnetwork/ipallocator"
 	"github.com/docker/libnetwork/iptables"
@@ -770,7 +769,7 @@ func addToBridge(ifaceName, bridgeName string) error {
 		return fmt.Errorf("could not find bridge %s: %v", bridgeName, err)
 	}
 
-	return bri.AddToBridge(iface, master)
+	return ioctlAddToBridge(iface, master)
 }
 
 func (d *driver) CreateEndpoint(nid, eid types.UUID, epInfo driverapi.EndpointInfo, epOptions map[string]interface{}) error {

libnetwork/drivers/bridge/netlink_deprecated_linux.go

@@ -0,0 +1,139 @@
+package bridge
+
+import (
+	"fmt"
+	"math/rand"
+	"net"
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+const (
+	ifNameSize   = 16
+	ioctlBrAdd   = 0x89a0
+	ioctlBrAddIf = 0x89a2
+)
+
+type ifreqIndex struct {
+	IfrnName  [ifNameSize]byte
+	IfruIndex int32
+}
+
+type ifreqHwaddr struct {
+	IfrnName   [ifNameSize]byte
+	IfruHwaddr syscall.RawSockaddr
+}
+
+var rnd = rand.New(rand.NewSource(time.Now().UnixNano()))
+
+// THIS CODE DOES NOT COMMUNICATE WITH KERNEL VIA RTNETLINK INTERFACE
+// IT IS HERE FOR BACKWARDS COMPATIBILITY WITH OLDER LINUX KERNELS
+// WHICH SHIP WITH OLDER NOT ENTIRELY FUNCTIONAL VERSION OF NETLINK
+func getIfSocket() (fd int, err error) {
+	for _, socket := range []int{
+		syscall.AF_INET,
+		syscall.AF_PACKET,
+		syscall.AF_INET6,
+	} {
+		if fd, err = syscall.Socket(socket, syscall.SOCK_DGRAM, 0); err == nil {
+			break
+		}
+	}
+	if err == nil {
+		return fd, nil
+	}
+	return -1, err
+}
+
+func ifIoctBridge(iface, master *net.Interface, op uintptr) error {
+	if len(master.Name) >= ifNameSize {
+		return fmt.Errorf("Interface name %s too long", master.Name)
+	}
+
+	s, err := getIfSocket()
+	if err != nil {
+		return err
+	}
+	defer syscall.Close(s)
+
+	ifr := ifreqIndex{}
+	copy(ifr.IfrnName[:len(ifr.IfrnName)-1], master.Name)
+	ifr.IfruIndex = int32(iface.Index)
+
+	if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, uintptr(s), op, uintptr(unsafe.Pointer(&ifr))); err != 0 {
+		return err
+	}
+
+	return nil
+}
+
+// Add a slave to a bridge device.  This is more backward-compatible than
+// netlink.NetworkSetMaster and works on RHEL 6.
+func ioctlAddToBridge(iface, master *net.Interface) error {
+	return ifIoctBridge(iface, master, ioctlBrAddIf)
+}
+
+func randMacAddr() string {
+	hw := make(net.HardwareAddr, 6)
+	for i := 0; i < 6; i++ {
+		hw[i] = byte(rnd.Intn(255))
+	}
+	hw[0] &^= 0x1 // clear multicast bit
+	hw[0] |= 0x2  // set local assignment bit (IEEE802)
+	return hw.String()
+}
+
+func ioctlSetMacAddress(name, addr string) error {
+	if len(name) >= ifNameSize {
+		return fmt.Errorf("Interface name %s too long", name)
+	}
+
+	hw, err := net.ParseMAC(addr)
+	if err != nil {
+		return err
+	}
+
+	s, err := getIfSocket()
+	if err != nil {
+		return err
+	}
+	defer syscall.Close(s)
+
+	ifr := ifreqHwaddr{}
+	ifr.IfruHwaddr.Family = syscall.ARPHRD_ETHER
+	copy(ifr.IfrnName[:len(ifr.IfrnName)-1], name)
+
+	for i := 0; i < 6; i++ {
+		ifr.IfruHwaddr.Data[i] = ifrDataByte(hw[i])
+	}
+
+	if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, uintptr(s), syscall.SIOCSIFHWADDR, uintptr(unsafe.Pointer(&ifr))); err != 0 {
+		return err
+	}
+	return nil
+}
+
+func ioctlCreateBridge(name string, setMacAddr bool) error {
+	if len(name) >= ifNameSize {
+		return fmt.Errorf("Interface name %s too long", name)
+	}
+
+	s, err := getIfSocket()
+	if err != nil {
+		return err
+	}
+	defer syscall.Close(s)
+
+	nameBytePtr, err := syscall.BytePtrFromString(name)
+	if err != nil {
+		return err
+	}
+	if _, _, err := syscall.Syscall(syscall.SYS_IOCTL, uintptr(s), ioctlBrAdd, uintptr(unsafe.Pointer(nameBytePtr))); err != 0 {
+		return err
+	}
+	if setMacAddr {
+		return ioctlSetMacAddress(name, randMacAddr())
+	}
+	return nil
+}

libnetwork/drivers/bridge/netlink_deprecated_linux_armppc64.go

@@ -1,4 +1,6 @@
-package netlink
+// +build arm ppc64
+
+package bridge
 
 func ifrDataByte(b byte) uint8 {
 	return uint8(b)

libnetwork/drivers/bridge/netlink_deprecated_linux_notarm.go

@@ -1,6 +1,6 @@
-// +build !arm
+// +build !arm,!ppc64
 
-package netlink
+package bridge
 
 func ifrDataByte(b byte) int8 {
 	return int8(b)

libnetwork/drivers/bridge/netlink_deprecated_unsupported.go

@@ -0,0 +1,18 @@
+// +build !linux
+
+package bridge
+
+import (
+	"errors"
+	"net"
+)
+
+// Add a slave to a bridge device.  This is more backward-compatible than
+// netlink.NetworkSetMaster and works on RHEL 6.
+func ioctlAddToBridge(iface, master *net.Interface) error {
+	return errors.New("not implemented")
+}
+
+func ioctlCreateBridge(name string, setMacAddr bool) error {
+	return errors.New("not implemented")
+}

libnetwork/drivers/bridge/setup_device.go

@@ -2,7 +2,6 @@ package bridge
 
 import (
 	"github.com/docker/docker/pkg/parsers/kernel"
-	bri "github.com/docker/libcontainer/netlink"
 	"github.com/vishvananda/netlink"
 )
 
@@ -30,7 +29,7 @@ func setupDevice(config *networkConfiguration, i *bridgeInterface) error {
 		setMac = true
 	}
 
-	return bri.CreateBridge(config.BridgeName, setMac)
+	return ioctlCreateBridge(config.BridgeName, setMac)
 }
 
 // SetupDeviceUp ups the given bridge interface.