@@ -1,10 +1,10 @@

 package client

 import (

+	"encoding/json"

 	"fmt"

 	"strings"

-	"github.com/docker/docker/engine"

 	"github.com/docker/docker/nat"

 	flag "github.com/docker/docker/pkg/mflag"

 )

@@ -23,12 +23,13 @@ func (cli *DockerCli) CmdPort(args ...string) error {

 		return err

 	}

-	env := engine.Env{}

-	if err := env.Decode(stream); err != nil {

-		return err

+	var c struct {

+		NetworkSettings struct {

+			Ports nat.PortMap

+		}

 	}

-	ports := nat.PortMap{}

-	if err := env.GetSubEnv("NetworkSettings").GetJson("Ports", &ports); err != nil {

+

+	if err := json.NewDecoder(stream).Decode(&c); err != nil {

 		return err

 	}

@@ -44,7 +45,7 @@ func (cli *DockerCli) CmdPort(args ...string) error {

 			proto = parts[1]

 		}

 		natPort := port + "/" + proto

-		if frontends, exists := ports[nat.Port(port+"/"+proto)]; exists && frontends != nil {

+		if frontends, exists := c.NetworkSettings.Ports[nat.Port(port+"/"+proto)]; exists && frontends != nil {

 			for _, frontend := range frontends {

 				fmt.Fprintf(cli.out, "%s:%s\n", frontend.HostIp, frontend.HostPort)

 			}

@@ -53,7 +54,7 @@ func (cli *DockerCli) CmdPort(args ...string) error {

 		return fmt.Errorf("Error: No public port '%s' published for %s", natPort, cmd.Arg(0))

 	}

-	for from, frontends := range ports {

+	for from, frontends := range c.NetworkSettings.Ports {

 		for _, frontend := range frontends {

 			fmt.Fprintf(cli.out, "%s -> %s:%s\n", from, frontend.HostIp, frontend.HostPort)

 		}

@@ -6,15 +6,11 @@ import (

 	"github.com/docker/docker/api"

 	apiserver "github.com/docker/docker/api/server"

 	"github.com/docker/docker/autogen/dockerversion"

-	"github.com/docker/docker/daemon/networkdriver/bridge"

 	"github.com/docker/docker/engine"

 	"github.com/docker/docker/pkg/parsers/kernel"

 )

 func Register(eng *engine.Engine) error {

-	if err := daemon(eng); err != nil {

-		return err

-	}

 	if err := remote(eng); err != nil {

 		return err

 	}

@@ -33,25 +29,6 @@ func remote(eng *engine.Engine) error {

 	return eng.Register("acceptconnections", apiserver.AcceptConnections)

 }

-// daemon: a default execution and storage backend for Docker on Linux,

-// with the following underlying components:

-//

-// * Pluggable storage drivers including aufs, vfs, lvm and btrfs.

-// * Pluggable execution drivers including lxc and chroot.

-//

-// In practice `daemon` still includes most core Docker components, including:

-//

-// * The reference registry client implementation

-// * Image management

-// * The build facility

-// * Logging

-//

-// These components should be broken off into plugins of their own.

-//

-func daemon(eng *engine.Engine) error {

-	return eng.Register("init_networkdriver", bridge.InitDriver)

-}

-

 // builtins jobs independent of any subsystem

 func dockerVersion(job *engine.Job) error {

 	v := &engine.Env{}

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

 package daemon

 import (

-	"net"

-

 	"github.com/docker/docker/daemon/networkdriver"

+	"github.com/docker/docker/daemon/networkdriver/bridge"

 	"github.com/docker/docker/opts"

 	flag "github.com/docker/docker/pkg/mflag"

 	"github.com/docker/docker/pkg/ulimit"

@@ -20,35 +19,27 @@ const (

 // to the docker daemon when you launch it with say: `docker -d -e lxc`

 // FIXME: separate runtime configuration from http api configuration

 type Config struct {

-	Pidfile                     string

-	Root                        string

-	AutoRestart                 bool

-	Dns                         []string

-	DnsSearch                   []string

-	EnableIPv6                  bool

-	EnableIptables              bool

-	EnableIpForward             bool

-	EnableIpMasq                bool

-	DefaultIp                   net.IP

-	BridgeIface                 string

-	BridgeIP                    string

-	FixedCIDR                   string

-	FixedCIDRv6                 string

-	InterContainerCommunication bool

-	GraphDriver                 string

-	GraphOptions                []string

-	ExecDriver                  string

-	Mtu                         int

-	SocketGroup                 string

-	EnableCors                  bool

-	CorsHeaders                 string

-	DisableNetwork              bool

-	EnableSelinuxSupport        bool

-	Context                     map[string][]string

-	TrustKeyPath                string

-	Labels                      []string

-	Ulimits                     map[string]*ulimit.Ulimit

-	LogConfig                   runconfig.LogConfig

+	Bridge bridge.Config

+

+	Pidfile              string

+	Root                 string

+	AutoRestart          bool

+	Dns                  []string

+	DnsSearch            []string

+	GraphDriver          string

+	GraphOptions         []string

+	ExecDriver           string

+	Mtu                  int

+	SocketGroup          string

+	EnableCors           bool

+	CorsHeaders          string

+	DisableNetwork       bool

+	EnableSelinuxSupport bool

+	Context              map[string][]string

+	TrustKeyPath         string

+	Labels               []string

+	Ulimits              map[string]*ulimit.Ulimit

+	LogConfig            runconfig.LogConfig

 }

 // InstallFlags adds command-line options to the top-level flag parser for

@@ -59,15 +50,15 @@ func (config *Config) InstallFlags() {

 	flag.StringVar(&config.Pidfile, []string{"p", "-pidfile"}, "/var/run/docker.pid", "Path to use for daemon PID file")

 	flag.StringVar(&config.Root, []string{"g", "-graph"}, "/var/lib/docker", "Root of the Docker runtime")

 	flag.BoolVar(&config.AutoRestart, []string{"#r", "#-restart"}, true, "--restart on the daemon has been deprecated in favor of --restart policies on docker run")

-	flag.BoolVar(&config.EnableIptables, []string{"#iptables", "-iptables"}, true, "Enable addition of iptables rules")

-	flag.BoolVar(&config.EnableIpForward, []string{"#ip-forward", "-ip-forward"}, true, "Enable net.ipv4.ip_forward")

-	flag.BoolVar(&config.EnableIpMasq, []string{"-ip-masq"}, true, "Enable IP masquerading")

-	flag.BoolVar(&config.EnableIPv6, []string{"-ipv6"}, false, "Enable IPv6 networking")

-	flag.StringVar(&config.BridgeIP, []string{"#bip", "-bip"}, "", "Specify network bridge IP")

-	flag.StringVar(&config.BridgeIface, []string{"b", "-bridge"}, "", "Attach containers to a network bridge")

-	flag.StringVar(&config.FixedCIDR, []string{"-fixed-cidr"}, "", "IPv4 subnet for fixed IPs")

-	flag.StringVar(&config.FixedCIDRv6, []string{"-fixed-cidr-v6"}, "", "IPv6 subnet for fixed IPs")

-	flag.BoolVar(&config.InterContainerCommunication, []string{"#icc", "-icc"}, true, "Enable inter-container communication")

+	flag.BoolVar(&config.Bridge.EnableIptables, []string{"#iptables", "-iptables"}, true, "Enable addition of iptables rules")

+	flag.BoolVar(&config.Bridge.EnableIpForward, []string{"#ip-forward", "-ip-forward"}, true, "Enable net.ipv4.ip_forward")

+	flag.BoolVar(&config.Bridge.EnableIpMasq, []string{"-ip-masq"}, true, "Enable IP masquerading")

+	flag.BoolVar(&config.Bridge.EnableIPv6, []string{"-ipv6"}, false, "Enable IPv6 networking")

+	flag.StringVar(&config.Bridge.IP, []string{"#bip", "-bip"}, "", "Specify network bridge IP")

+	flag.StringVar(&config.Bridge.Iface, []string{"b", "-bridge"}, "", "Attach containers to a network bridge")

+	flag.StringVar(&config.Bridge.FixedCIDR, []string{"-fixed-cidr"}, "", "IPv4 subnet for fixed IPs")

+	flag.StringVar(&config.Bridge.FixedCIDRv6, []string{"-fixed-cidr-v6"}, "", "IPv6 subnet for fixed IPs")

+	flag.BoolVar(&config.Bridge.InterContainerCommunication, []string{"#icc", "-icc"}, true, "Enable inter-container communication")

 	flag.StringVar(&config.GraphDriver, []string{"s", "-storage-driver"}, "", "Storage driver to use")

 	flag.StringVar(&config.ExecDriver, []string{"e", "-exec-driver"}, "native", "Exec driver to use")

 	flag.BoolVar(&config.EnableSelinuxSupport, []string{"-selinux-enabled"}, false, "Enable selinux support")

@@ -75,7 +66,7 @@ func (config *Config) InstallFlags() {

 	flag.StringVar(&config.SocketGroup, []string{"G", "-group"}, "docker", "Group for the unix socket")

 	flag.BoolVar(&config.EnableCors, []string{"#api-enable-cors", "#-api-enable-cors"}, false, "Enable CORS headers in the remote API, this is deprecated by --api-cors-header")

 	flag.StringVar(&config.CorsHeaders, []string{"-api-cors-header"}, "", "Set CORS headers in the remote API")

-	opts.IPVar(&config.DefaultIp, []string{"#ip", "-ip"}, "0.0.0.0", "Default IP when binding container ports")

+	opts.IPVar(&config.Bridge.DefaultIp, []string{"#ip", "-ip"}, "0.0.0.0", "Default IP when binding container ports")

 	opts.ListVar(&config.GraphOptions, []string{"-storage-opt"}, "Set storage driver options")

 	// FIXME: why the inconsistency between "hosts" and "sockets"?

 	opts.IPListVar(&config.Dns, []string{"#dns", "-dns"}, "DNS server to use")

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

 	"github.com/docker/docker/daemon/logger"

 	"github.com/docker/docker/daemon/logger/jsonfilelog"

 	"github.com/docker/docker/daemon/logger/syslog"

+	"github.com/docker/docker/daemon/network"

+	"github.com/docker/docker/daemon/networkdriver/bridge"

 	"github.com/docker/docker/engine"

 	"github.com/docker/docker/image"

 	"github.com/docker/docker/links"

@@ -73,7 +75,7 @@ type Container struct {

 	Config  *runconfig.Config

 	ImageID string `json:"Image"`

-	NetworkSettings *NetworkSettings

+	NetworkSettings *network.Settings

 	ResolvConfPath string

 	HostnamePath   string

@@ -571,17 +573,12 @@ func (container *Container) AllocateNetwork() error {

 	}

 	var (

-		env *engine.Env

 		err error

 		eng = container.daemon.eng

 	)

-	job := eng.Job("allocate_interface", container.ID)

-	job.Setenv("RequestedMac", container.Config.MacAddress)

-	if env, err = job.Stdout.AddEnv(); err != nil {

-		return err

-	}

-	if err = job.Run(); err != nil {

+	networkSettings, err := bridge.Allocate(container.ID, container.Config.MacAddress, "", "")

+	if err != nil {

 		return err

 	}

@@ -591,12 +588,12 @@ func (container *Container) AllocateNetwork() error {

 	if container.Config.PortSpecs != nil {

 		if err = migratePortMappings(container.Config, container.hostConfig); err != nil {

-			eng.Job("release_interface", container.ID).Run()

+			bridge.Release(container.ID)

 			return err

 		}

 		container.Config.PortSpecs = nil

 		if err = container.WriteHostConfig(); err != nil {

-			eng.Job("release_interface", container.ID).Run()

+			bridge.Release(container.ID)

 			return err

 		}

 	}

@@ -626,23 +623,14 @@ func (container *Container) AllocateNetwork() error {

 	for port := range portSpecs {

 		if err = container.allocatePort(eng, port, bindings); err != nil {

-			eng.Job("release_interface", container.ID).Run()

+			bridge.Release(container.ID)

 			return err

 		}

 	}

 	container.WriteHostConfig()

-	container.NetworkSettings.Ports = bindings

-	container.NetworkSettings.Bridge = env.Get("Bridge")

-	container.NetworkSettings.IPAddress = env.Get("IP")

-	container.NetworkSettings.IPPrefixLen = env.GetInt("IPPrefixLen")

-	container.NetworkSettings.MacAddress = env.Get("MacAddress")

-	container.NetworkSettings.Gateway = env.Get("Gateway")

-	container.NetworkSettings.LinkLocalIPv6Address = env.Get("LinkLocalIPv6")

-	container.NetworkSettings.LinkLocalIPv6PrefixLen = 64

-	container.NetworkSettings.GlobalIPv6Address = env.Get("GlobalIPv6")

-	container.NetworkSettings.GlobalIPv6PrefixLen = env.GetInt("GlobalIPv6PrefixLen")

-	container.NetworkSettings.IPv6Gateway = env.Get("IPv6Gateway")

+	networkSettings.Ports = bindings

+	container.NetworkSettings = networkSettings

 	return nil

 }

@@ -651,12 +639,10 @@ func (container *Container) ReleaseNetwork() {

 	if container.Config.NetworkDisabled || !container.hostConfig.NetworkMode.IsPrivate() {

 		return

 	}

-	eng := container.daemon.eng

-	job := eng.Job("release_interface", container.ID)

-	job.SetenvBool("overrideShutdown", true)

-	job.Run()

-	container.NetworkSettings = &NetworkSettings{}

+	bridge.Release(container.ID)

+

+	container.NetworkSettings = &network.Settings{}

 }

 func (container *Container) isNetworkAllocated() bool {

@@ -675,10 +661,7 @@ func (container *Container) RestoreNetwork() error {

 	eng := container.daemon.eng

 	// Re-allocate the interface with the same IP and MAC address.

-	job := eng.Job("allocate_interface", container.ID)

-	job.Setenv("RequestedIP", container.NetworkSettings.IPAddress)

-	job.Setenv("RequestedMac", container.NetworkSettings.MacAddress)

-	if err := job.Run(); err != nil {

+	if _, err := bridge.Allocate(container.ID, container.NetworkSettings.MacAddress, container.NetworkSettings.IPAddress, ""); err != nil {

 		return err

 	}

@@ -1077,7 +1060,7 @@ func (container *Container) setupContainerDns() error {

 			latestResolvConf, latestHash := resolvconf.GetLastModified()

 			// clean container resolv.conf re: localhost nameservers and IPv6 NS (if IPv6 disabled)

-			updatedResolvConf, modified := resolvconf.FilterResolvDns(latestResolvConf, container.daemon.config.EnableIPv6)

+			updatedResolvConf, modified := resolvconf.FilterResolvDns(latestResolvConf, container.daemon.config.Bridge.EnableIPv6)

 			if modified {

 				// changes have occurred during resolv.conf localhost cleanup: generate an updated hash

 				newHash, err := utils.HashData(bytes.NewReader(updatedResolvConf))

@@ -1131,7 +1114,7 @@ func (container *Container) setupContainerDns() error {

 		}

 		// replace any localhost/127.*, and remove IPv6 nameservers if IPv6 disabled in daemon

-		resolvConf, _ = resolvconf.FilterResolvDns(resolvConf, daemon.config.EnableIPv6)

+		resolvConf, _ = resolvconf.FilterResolvDns(resolvConf, daemon.config.Bridge.EnableIPv6)

 	}

 	//get a sha256 hash of the resolv conf at this point so we can check

 	//for changes when the host resolv.conf changes (e.g. network update)

@@ -1481,24 +1464,10 @@ func (container *Container) allocatePort(eng *engine.Engine, port nat.Port, bind

 	}

 	for i := 0; i < len(binding); i++ {

-		b := binding[i]

-

-		job := eng.Job("allocate_port", container.ID)

-		job.Setenv("HostIP", b.HostIp)

-		job.Setenv("HostPort", b.HostPort)

-		job.Setenv("Proto", port.Proto())

-		job.Setenv("ContainerPort", port.Port())

-

-		portEnv, err := job.Stdout.AddEnv()

+		b, err := bridge.AllocatePort(container.ID, port, binding[i])

 		if err != nil {

 			return err

 		}

-		if err := job.Run(); err != nil {

-			return err

-		}

-		b.HostIp = portEnv.Get("HostIP")

-		b.HostPort = portEnv.Get("HostPort")

-

 		binding[i] = b

 	}

 	bindings[port] = binding

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

 	"github.com/docker/docker/daemon/execdriver/lxc"

 	"github.com/docker/docker/daemon/graphdriver"

 	_ "github.com/docker/docker/daemon/graphdriver/vfs"

-	_ "github.com/docker/docker/daemon/networkdriver/bridge"

+	"github.com/docker/docker/daemon/network"

+	"github.com/docker/docker/daemon/networkdriver/bridge"

 	"github.com/docker/docker/engine"

 	"github.com/docker/docker/graph"

 	"github.com/docker/docker/image"

@@ -445,7 +446,7 @@ func (daemon *Daemon) setupResolvconfWatcher() error {

 						logrus.Debugf("Error retrieving updated host resolv.conf: %v", err)

 					} else if updatedResolvConf != nil {

 						// because the new host resolv.conf might have localhost nameservers..

-						updatedResolvConf, modified := resolvconf.FilterResolvDns(updatedResolvConf, daemon.config.EnableIPv6)

+						updatedResolvConf, modified := resolvconf.FilterResolvDns(updatedResolvConf, daemon.config.Bridge.EnableIPv6)

 						if modified {

 							// changes have occurred during localhost cleanup: generate an updated hash

 							newHash, err := utils.HashData(bytes.NewReader(updatedResolvConf))

@@ -653,7 +654,7 @@ func (daemon *Daemon) newContainer(name string, config *runconfig.Config, imgID

 		Config:          config,

 		hostConfig:      &runconfig.HostConfig{},

 		ImageID:         imgID,

-		NetworkSettings: &NetworkSettings{},

+		NetworkSettings: &network.Settings{},

 		Name:            name,

 		Driver:          daemon.driver.String(),

 		ExecDriver:      daemon.execDriver.Name(),

@@ -807,16 +808,16 @@ func NewDaemonFromDirectory(config *Config, eng *engine.Engine, registryService

 		config.Mtu = getDefaultNetworkMtu()

 	}

 	// Check for mutually incompatible config options

-	if config.BridgeIface != "" && config.BridgeIP != "" {

+	if config.Bridge.Iface != "" && config.Bridge.IP != "" {

 		return nil, fmt.Errorf("You specified -b & --bip, mutually exclusive options. Please specify only one.")

 	}

-	if !config.EnableIptables && !config.InterContainerCommunication {

+	if !config.Bridge.EnableIptables && !config.Bridge.InterContainerCommunication {

 		return nil, fmt.Errorf("You specified --iptables=false with --icc=false. ICC uses iptables to function. Please set --icc or --iptables to true.")

 	}

-	if !config.EnableIptables && config.EnableIpMasq {

-		config.EnableIpMasq = false

+	if !config.Bridge.EnableIptables && config.Bridge.EnableIpMasq {

+		config.Bridge.EnableIpMasq = false

 	}

-	config.DisableNetwork = config.BridgeIface == disableNetworkBridge

+	config.DisableNetwork = config.Bridge.Iface == disableNetworkBridge

 	// Claim the pidfile first, to avoid any and all unexpected race conditions.

 	// Some of the init doesn't need a pidfile lock - but let's not try to be smart.

@@ -948,20 +949,7 @@ func NewDaemonFromDirectory(config *Config, eng *engine.Engine, registryService

 	}

 	if !config.DisableNetwork {

-		job := eng.Job("init_networkdriver")

-

-		job.SetenvBool("EnableIptables", config.EnableIptables)

-		job.SetenvBool("InterContainerCommunication", config.InterContainerCommunication)

-		job.SetenvBool("EnableIpForward", config.EnableIpForward)

-		job.SetenvBool("EnableIpMasq", config.EnableIpMasq)

-		job.SetenvBool("EnableIPv6", config.EnableIPv6)

-		job.Setenv("BridgeIface", config.BridgeIface)

-		job.Setenv("BridgeIP", config.BridgeIP)

-		job.Setenv("FixedCIDR", config.FixedCIDR)

-		job.Setenv("FixedCIDRv6", config.FixedCIDRv6)

-		job.Setenv("DefaultBindingIP", config.DefaultIp.String())

-

-		if err := job.Run(); err != nil {

+		if err := bridge.InitDriver(&config.Bridge); err != nil {

 			return nil, err

 		}

 	}

new file mode 100644

@@ -0,0 +1,18 @@

+package network

+

+import "github.com/docker/docker/nat"

+

+type Settings struct {

+	IPAddress              string

+	IPPrefixLen            int

+	MacAddress             string

+	LinkLocalIPv6Address   string

+	LinkLocalIPv6PrefixLen int

+	GlobalIPv6Address      string

+	GlobalIPv6PrefixLen    int

+	Gateway                string

+	IPv6Gateway            string

+	Bridge                 string

+	PortMapping            map[string]map[string]string // Deprecated

+	Ports                  nat.PortMap

+}

deleted file mode 100644

@@ -1,23 +0,0 @@

-package daemon

-

-import (

-	"github.com/docker/docker/nat"

-)

-

-// FIXME: move deprecated port stuff to nat to clean up the core.

-type PortMapping map[string]string // Deprecated

-

-type NetworkSettings struct {

-	IPAddress              string

-	IPPrefixLen            int

-	MacAddress             string

-	LinkLocalIPv6Address   string

-	LinkLocalIPv6PrefixLen int

-	GlobalIPv6Address      string

-	GlobalIPv6PrefixLen    int

-	Gateway                string

-	IPv6Gateway            string

-	Bridge                 string

-	PortMapping            map[string]PortMapping // Deprecated

-	Ports                  nat.PortMap

-}

@@ -7,14 +7,15 @@ import (

 	"io/ioutil"

 	"net"

 	"os"

+	"strconv"

 	"strings"

 	"sync"

 	"github.com/Sirupsen/logrus"

+	"github.com/docker/docker/daemon/network"

 	"github.com/docker/docker/daemon/networkdriver"

 	"github.com/docker/docker/daemon/networkdriver/ipallocator"

 	"github.com/docker/docker/daemon/networkdriver/portmapper"

-	"github.com/docker/docker/engine"

 	"github.com/docker/docker/nat"

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

 	"github.com/docker/docker/pkg/parsers/kernel"

@@ -91,29 +92,34 @@ func initPortMapper() {

 	})

 }

-func InitDriver(job *engine.Job) error {

+type Config struct {

+	EnableIPv6                  bool

+	EnableIptables              bool

+	EnableIpForward             bool

+	EnableIpMasq                bool

+	DefaultIp                   net.IP

+	Iface                       string

+	IP                          string

+	FixedCIDR                   string

+	FixedCIDRv6                 string

+	InterContainerCommunication bool

+}

+

+func InitDriver(config *Config) error {

 	var (

-		networkv4      *net.IPNet

-		networkv6      *net.IPNet

-		addrv4         net.Addr

-		addrsv6        []net.Addr

-		enableIPTables = job.GetenvBool("EnableIptables")

-		enableIPv6     = job.GetenvBool("EnableIPv6")

-		icc            = job.GetenvBool("InterContainerCommunication")

-		ipMasq         = job.GetenvBool("EnableIpMasq")

-		ipForward      = job.GetenvBool("EnableIpForward")

-		bridgeIP       = job.Getenv("BridgeIP")

-		bridgeIPv6     = "fe80::1/64"

-		fixedCIDR      = job.Getenv("FixedCIDR")

-		fixedCIDRv6    = job.Getenv("FixedCIDRv6")

+		networkv4  *net.IPNet

+		networkv6  *net.IPNet

+		addrv4     net.Addr

+		addrsv6    []net.Addr

+		bridgeIPv6 = "fe80::1/64"

 	)

 	initPortMapper()

-	if defaultIP := job.Getenv("DefaultBindingIP"); defaultIP != "" {

-		defaultBindingIP = net.ParseIP(defaultIP)

+	if config.DefaultIp != nil {

+		defaultBindingIP = config.DefaultIp

 	}

-	bridgeIface = job.Getenv("BridgeIface")

+	bridgeIface = config.Iface

 	usingDefaultBridge := false

 	if bridgeIface == "" {

 		usingDefaultBridge = true

@@ -130,7 +136,7 @@ func InitDriver(job *engine.Job) error {

 		}

 		// If the iface is not found, try to create it

-		if err := configureBridge(bridgeIP, bridgeIPv6, enableIPv6); err != nil {

+		if err := configureBridge(config.IP, bridgeIPv6, config.EnableIPv6); err != nil {

 			return err

 		}

@@ -139,19 +145,19 @@ func InitDriver(job *engine.Job) error {

 			return err

 		}

-		if fixedCIDRv6 != "" {

+		if config.FixedCIDRv6 != "" {

 			// Setting route to global IPv6 subnet

-			logrus.Infof("Adding route to IPv6 network %q via device %q", fixedCIDRv6, bridgeIface)

-			if err := netlink.AddRoute(fixedCIDRv6, "", "", bridgeIface); err != nil {

-				logrus.Fatalf("Could not add route to IPv6 network %q via device %q", fixedCIDRv6, bridgeIface)

+			logrus.Infof("Adding route to IPv6 network %q via device %q", config.FixedCIDRv6, bridgeIface)

+			if err := netlink.AddRoute(config.FixedCIDRv6, "", "", bridgeIface); err != nil {

+				logrus.Fatalf("Could not add route to IPv6 network %q via device %q", config.FixedCIDRv6, bridgeIface)

 			}

 		}

 	} else {

 		// Bridge exists already, getting info...

 		// Validate that the bridge ip matches the ip specified by BridgeIP

-		if bridgeIP != "" {

+		if config.IP != "" {

 			networkv4 = addrv4.(*net.IPNet)

-			bip, _, err := net.ParseCIDR(bridgeIP)

+			bip, _, err := net.ParseCIDR(config.IP)

 			if err != nil {

 				return err

 			}

@@ -164,7 +170,7 @@ func InitDriver(job *engine.Job) error {

 		// (for example, an existing Docker installation that has only been used

 		// with IPv4 and docker0 already is set up) In that case, we can perform

 		// the bridge init for IPv6 here, else we will error out below if --ipv6=true

-		if len(addrsv6) == 0 && enableIPv6 {

+		if len(addrsv6) == 0 && config.EnableIPv6 {

 			if err := setupIPv6Bridge(bridgeIPv6); err != nil {

 				return err

 			}

@@ -175,10 +181,10 @@ func InitDriver(job *engine.Job) error {

 			}

 		}

-		// TODO: Check if route to fixedCIDRv6 is set

+		// TODO: Check if route to config.FixedCIDRv6 is set

 	}

-	if enableIPv6 {

+	if config.EnableIPv6 {

 		bip6, _, err := net.ParseCIDR(bridgeIPv6)

 		if err != nil {

 			return err

@@ -198,7 +204,7 @@ func InitDriver(job *engine.Job) error {

 	networkv4 = addrv4.(*net.IPNet)

-	if enableIPv6 {

+	if config.EnableIPv6 {

 		if len(addrsv6) == 0 {

 			return errors.New("IPv6 enabled but no IPv6 detected")

 		}

@@ -206,20 +212,20 @@ func InitDriver(job *engine.Job) error {

 	}

 	// Configure iptables for link support

-	if enableIPTables {

-		if err := setupIPTables(addrv4, icc, ipMasq); err != nil {

+	if config.EnableIptables {

+		if err := setupIPTables(addrv4, config.InterContainerCommunication, config.EnableIpMasq); err != nil {

 			return err

 		}

 	}

-	if ipForward {

+	if config.EnableIpForward {

 		// Enable IPv4 forwarding

 		if err := ioutil.WriteFile("/proc/sys/net/ipv4/ip_forward", []byte{'1', '\n'}, 0644); err != nil {

 			logrus.Warnf("WARNING: unable to enable IPv4 forwarding: %s\n", err)

 		}

-		if fixedCIDRv6 != "" {

+		if config.FixedCIDRv6 != "" {

 			// Enable IPv6 forwarding

 			if err := ioutil.WriteFile("/proc/sys/net/ipv6/conf/default/forwarding", []byte{'1', '\n'}, 0644); err != nil {

 				logrus.Warnf("WARNING: unable to enable IPv6 default forwarding: %s\n", err)

@@ -235,7 +241,7 @@ func InitDriver(job *engine.Job) error {

 		return err

 	}

-	if enableIPTables {

+	if config.EnableIptables {

 		_, err := iptables.NewChain("DOCKER", bridgeIface, iptables.Nat)

 		if err != nil {

 			return err

@@ -248,8 +254,8 @@ func InitDriver(job *engine.Job) error {

 	}

 	bridgeIPv4Network = networkv4

-	if fixedCIDR != "" {

-		_, subnet, err := net.ParseCIDR(fixedCIDR)

+	if config.FixedCIDR != "" {

+		_, subnet, err := net.ParseCIDR(config.FixedCIDR)

 		if err != nil {

 			return err

 		}

@@ -259,8 +265,8 @@ func InitDriver(job *engine.Job) error {

 		}

 	}

-	if fixedCIDRv6 != "" {

-		_, subnet, err := net.ParseCIDR(fixedCIDRv6)

+	if config.FixedCIDRv6 != "" {

+		_, subnet, err := net.ParseCIDR(config.FixedCIDRv6)

 		if err != nil {

 			return err

 		}

@@ -274,19 +280,6 @@ func InitDriver(job *engine.Job) error {

 	// Block BridgeIP in IP allocator

 	ipAllocator.RequestIP(bridgeIPv4Network, bridgeIPv4Network.IP)

-	// https://github.com/docker/docker/issues/2768

-	job.Eng.HackSetGlobalVar("httpapi.bridgeIP", bridgeIPv4Network.IP)

-

-	for name, f := range map[string]engine.Handler{

-		"allocate_interface": Allocate,

-		"release_interface":  Release,

-		"allocate_port":      AllocatePort,

-		"link":               LinkContainers,

-	} {

-		if err := job.Eng.Register(name, f); err != nil {

-			return err

-		}

-	}

 	return nil

 }

@@ -513,70 +506,67 @@ func linkLocalIPv6FromMac(mac string) (string, error) {

 }

 // Allocate a network interface

-func Allocate(job *engine.Job) error {

+func Allocate(id, requestedMac, requestedIP, requestedIPv6 string) (*network.Settings, error) {

 	var (

-		ip            net.IP

-		mac           net.HardwareAddr

-		err           error

-		id            = job.Args[0]

-		requestedIP   = net.ParseIP(job.Getenv("RequestedIP"))

-		requestedIPv6 = net.ParseIP(job.Getenv("RequestedIPv6"))

-		globalIPv6    net.IP

+		ip         net.IP

+		mac        net.HardwareAddr

+		err        error

+		globalIPv6 net.IP

 	)

-	ip, err = ipAllocator.RequestIP(bridgeIPv4Network, requestedIP)

+	ip, err = ipAllocator.RequestIP(bridgeIPv4Network, net.ParseIP(requestedIP))

 	if err != nil {

-		return err

+		return nil, err

 	}

 	// If no explicit mac address was given, generate a random one.

-	if mac, err = net.ParseMAC(job.Getenv("RequestedMac")); err != nil {

+	if mac, err = net.ParseMAC(requestedMac); err != nil {

 		mac = generateMacAddr(ip)

 	}

 	if globalIPv6Network != nil {

 		// If globalIPv6Network Size is at least a /80 subnet generate IPv6 address from MAC address

 		netmaskOnes, _ := globalIPv6Network.Mask.Size()

-		if requestedIPv6 == nil && netmaskOnes <= 80 {

-			requestedIPv6 = make(net.IP, len(globalIPv6Network.IP))

-			copy(requestedIPv6, globalIPv6Network.IP)

+		ipv6 := net.ParseIP(requestedIPv6)

+		if ipv6 == nil && netmaskOnes <= 80 {

+			ipv6 = make(net.IP, len(globalIPv6Network.IP))

+			copy(ipv6, globalIPv6Network.IP)

 			for i, h := range mac {

-				requestedIPv6[i+10] = h

+				ipv6[i+10] = h

 			}

 		}

-		globalIPv6, err = ipAllocator.RequestIP(globalIPv6Network, requestedIPv6)

+		globalIPv6, err = ipAllocator.RequestIP(globalIPv6Network, ipv6)

 		if err != nil {

 			logrus.Errorf("Allocator: RequestIP v6: %v", err)

-			return err

+			return nil, err

 		}

 		logrus.Infof("Allocated IPv6 %s", globalIPv6)

 	}

-	out := engine.Env{}

-	out.Set("IP", ip.String())

-	out.Set("Mask", bridgeIPv4Network.Mask.String())

-	out.Set("Gateway", bridgeIPv4Network.IP.String())

-	out.Set("MacAddress", mac.String())

-	out.Set("Bridge", bridgeIface)

-

-	size, _ := bridgeIPv4Network.Mask.Size()

-	out.SetInt("IPPrefixLen", size)

+	maskSize, _ := bridgeIPv4Network.Mask.Size()

 	// If linklocal IPv6

 	localIPv6Net, err := linkLocalIPv6FromMac(mac.String())

 	if err != nil {

-		return err

+		return nil, err

 	}

 	localIPv6, _, _ := net.ParseCIDR(localIPv6Net)

-	out.Set("LinkLocalIPv6", localIPv6.String())

-	out.Set("MacAddress", mac.String())

+

+	networkSettings := &network.Settings{

+		IPAddress:            ip.String(),

+		Gateway:              bridgeIPv4Network.IP.String(),

+		MacAddress:           mac.String(),

+		Bridge:               bridgeIface,

+		IPPrefixLen:          maskSize,

+		LinkLocalIPv6Address: localIPv6.String(),

+	}

 	if globalIPv6Network != nil {

-		out.Set("GlobalIPv6", globalIPv6.String())

-		sizev6, _ := globalIPv6Network.Mask.Size()

-		out.SetInt("GlobalIPv6PrefixLen", sizev6)

-		out.Set("IPv6Gateway", bridgeIPv6Addr.String())

+		networkSettings.GlobalIPv6Address = globalIPv6.String()

+		maskV6Size, _ := globalIPv6Network.Mask.Size()

+		networkSettings.GlobalIPv6PrefixLen = maskV6Size

+		networkSettings.IPv6Gateway = bridgeIPv6Addr.String()

 	}

 	currentInterfaces.Set(id, &networkInterface{

@@ -584,20 +574,15 @@ func Allocate(job *engine.Job) error {

 		IPv6: globalIPv6,

 	})

-	out.WriteTo(job.Stdout)

-

-	return nil

+	return networkSettings, nil

 }

 // Release an interface for a select ip

-func Release(job *engine.Job) error {

-	var (

-		id                 = job.Args[0]

-		containerInterface = currentInterfaces.Get(id)

-	)

+func Release(id string) {

+	var containerInterface = currentInterfaces.Get(id)

 	if containerInterface == nil {

-		return fmt.Errorf("No network information to release for %s", id)

+		logrus.Warnf("No network information to release for %s", id)

 	}

 	for _, nat := range containerInterface.PortMappings {

@@ -614,27 +599,21 @@ func Release(job *engine.Job) error {

 			logrus.Infof("Unable to release IPv6 %s", err)

 		}

 	}

-	return nil

 }

 // Allocate an external port and map it to the interface

-func AllocatePort(job *engine.Job) error {

+func AllocatePort(id string, port nat.Port, binding nat.PortBinding) (nat.PortBinding, error) {

 	var (

-		err error

-

 		ip            = defaultBindingIP

-		id            = job.Args[0]

-		hostIP        = job.Getenv("HostIP")

-		hostPort      = job.GetenvInt("HostPort")

-		containerPort = job.GetenvInt("ContainerPort")

-		proto         = job.Getenv("Proto")

+		proto         = port.Proto()

+		containerPort = port.Int()

 		network       = currentInterfaces.Get(id)

 	)

-	if hostIP != "" {

-		ip = net.ParseIP(hostIP)

+	if binding.HostIp != "" {

+		ip = net.ParseIP(binding.HostIp)

 		if ip == nil {

-			return fmt.Errorf("Bad parameter: invalid host ip %s", hostIP)

+			return nat.PortBinding{}, fmt.Errorf("Bad parameter: invalid host ip %s", binding.HostIp)

 		}

 	}

@@ -646,7 +625,7 @@ func AllocatePort(job *engine.Job) error {

 	case "udp":

 		container = &net.UDPAddr{IP: network.IP, Port: containerPort}

 	default:

-		return fmt.Errorf("unsupported address type %s", proto)

+		return nat.PortBinding{}, fmt.Errorf("unsupported address type %s", proto)

 	}

 	//

@@ -656,7 +635,14 @@ func AllocatePort(job *engine.Job) error {

 	// yields.

 	//

-	var host net.Addr

+	var (

+		host net.Addr

+		err  error

+	)

+	hostPort, err := nat.ParsePort(binding.HostPort)

+	if err != nil {

+		return nat.PortBinding{}, err

+	}

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

 		if host, err = portMapper.Map(container, ip, hostPort); err == nil {

 			break

@@ -671,36 +657,24 @@ func AllocatePort(job *engine.Job) error {

 	}

 	if err != nil {

-		return err

+		return nat.PortBinding{}, err

 	}

 	network.PortMappings = append(network.PortMappings, host)

-	out := engine.Env{}

 	switch netAddr := host.(type) {

 	case *net.TCPAddr:

-		out.Set("HostIP", netAddr.IP.String())

-		out.SetInt("HostPort", netAddr.Port)

+		return nat.PortBinding{HostIp: netAddr.IP.String(), HostPort: strconv.Itoa(netAddr.Port)}, nil

 	case *net.UDPAddr:

-		out.Set("HostIP", netAddr.IP.String())

-		out.SetInt("HostPort", netAddr.Port)

-	}

-	if _, err := out.WriteTo(job.Stdout); err != nil {

-		return err

+		return nat.PortBinding{HostIp: netAddr.IP.String(), HostPort: strconv.Itoa(netAddr.Port)}, nil

+	default:

+		return nat.PortBinding{}, fmt.Errorf("unsupported address type %T", netAddr)

 	}

-

-	return nil

 }