@@ -34,6 +34,7 @@ func (cli *DockerCli) CmdNetwork(args ...string) error {

 func (cli *DockerCli) CmdNetworkCreate(args ...string) error {

 	cmd := Cli.Subcmd("network create", []string{"NETWORK-NAME"}, "Creates a new network with a name specified by the user", false)

 	flDriver := cmd.String([]string{"d", "-driver"}, "bridge", "Driver to manage the Network")

+	flOpts := opts.NewMapOpts(nil, nil)

 	flIpamDriver := cmd.String([]string{"-ipam-driver"}, "default", "IP Address Management Driver")

 	flIpamSubnet := opts.NewListOpts(nil)

@@ -41,10 +42,11 @@ func (cli *DockerCli) CmdNetworkCreate(args ...string) error {

 	flIpamGateway := opts.NewListOpts(nil)

 	flIpamAux := opts.NewMapOpts(nil, nil)

-	cmd.Var(&flIpamSubnet, []string{"-subnet"}, "Subnet in CIDR format that represents a network segment")

+	cmd.Var(&flIpamSubnet, []string{"-subnet"}, "subnet in CIDR format that represents a network segment")

 	cmd.Var(&flIpamIPRange, []string{"-ip-range"}, "allocate container ip from a sub-range")

 	cmd.Var(&flIpamGateway, []string{"-gateway"}, "ipv4 or ipv6 Gateway for the master subnet")

-	cmd.Var(flIpamAux, []string{"-aux-address"}, "Auxiliary ipv4 or ipv6 addresses used by network driver")

+	cmd.Var(flIpamAux, []string{"-aux-address"}, "auxiliary ipv4 or ipv6 addresses used by Network driver")

+	cmd.Var(flOpts, []string{"o", "-opt"}, "set driver specific options")

 	cmd.Require(flag.Exact, 1)

 	err := cmd.ParseFlags(args, true)

@@ -62,6 +64,7 @@ func (cli *DockerCli) CmdNetworkCreate(args ...string) error {

 		Name:           cmd.Arg(0),

 		Driver:         *flDriver,

 		IPAM:           network.IPAM{Driver: *flIpamDriver, Config: ipamCfg},

+		Options:        flOpts.GetAll(),

 		CheckDuplicate: true,

 	}

 	obj, _, err := readBody(cli.call("POST", "/networks/create", nc, nil))

@@ -96,7 +96,7 @@ func (n *networkRouter) postNetworkCreate(ctx context.Context, w http.ResponseWr

 		warning = fmt.Sprintf("Network with name %s (id : %s) already exists", nw.Name(), nw.ID())

 	}

-	nw, err = n.daemon.CreateNetwork(create.Name, create.Driver, create.IPAM)

+	nw, err = n.daemon.CreateNetwork(create.Name, create.Driver, create.IPAM, create.Options)

 	if err != nil {

 		return err

 	}

@@ -174,6 +174,7 @@ func buildNetworkResource(nw libnetwork.Network) *types.NetworkResource {

 	r.ID = nw.ID()

 	r.Scope = nw.Info().Scope()

 	r.Driver = nw.Type()

+	r.Options = nw.Info().DriverOptions()

 	r.Containers = make(map[string]types.EndpointResource)

 	buildIpamResources(r, nw)

@@ -319,6 +319,7 @@ type NetworkResource struct {

 	Driver     string                      `json:"driver"`

 	IPAM       network.IPAM                `json:"ipam"`

 	Containers map[string]EndpointResource `json:"containers"`

+	Options    map[string]string           `json:"options"`

 }

 //EndpointResource contains network resources allocated and usd for a container in a network

@@ -331,10 +332,11 @@ type EndpointResource struct {

 // NetworkCreate is the expected body of the "create network" http request message

 type NetworkCreate struct {

-	Name           string       `json:"name"`

-	CheckDuplicate bool         `json:"check_duplicate"`

-	Driver         string       `json:"driver"`

-	IPAM           network.IPAM `json:"ipam"`

+	Name           string            `json:"name"`

+	CheckDuplicate bool              `json:"check_duplicate"`

+	Driver         string            `json:"driver"`

+	IPAM           network.IPAM      `json:"ipam"`

+	Options        map[string]string `json:"options"`

 }

 // NetworkCreateResponse is the response message sent by the server for network create call

@@ -80,7 +80,7 @@ func (daemon *Daemon) GetNetworksByID(partialID string) []libnetwork.Network {

 }

 // CreateNetwork creates a network with the given name, driver and other optional parameters

-func (daemon *Daemon) CreateNetwork(name, driver string, ipam network.IPAM) (libnetwork.Network, error) {

+func (daemon *Daemon) CreateNetwork(name, driver string, ipam network.IPAM, options map[string]string) (libnetwork.Network, error) {

 	c := daemon.netController

 	if driver == "" {

 		driver = c.Config().Daemon.DefaultDriver

@@ -96,6 +96,7 @@ func (daemon *Daemon) CreateNetwork(name, driver string, ipam network.IPAM) (lib

 	if len(ipam.Config) > 0 {

 		nwOptions = append(nwOptions, libnetwork.NetworkOptionIpam(ipam.Driver, "", v4Conf, v6Conf))

 	}

+	nwOptions = append(nwOptions, libnetwork.NetworkOptionDriverOpts(options))

 	return c.NewNetwork(driver, name, nwOptions...)

 }

@@ -74,9 +74,10 @@ func (s *DockerSuite) TestApiNetworkInspect(c *check.C) {

 		Config: []network.IPAMConfig{{Subnet: "172.28.0.0/16", IPRange: "172.28.5.0/24", Gateway: "172.28.5.254"}},

 	}

 	config := types.NetworkCreate{

-		Name:   "br0",

-		Driver: "bridge",

-		IPAM:   ipam,

+		Name:    "br0",

+		Driver:  "bridge",

+		IPAM:    ipam,

+		Options: map[string]string{"foo": "bar", "opts": "dopts"},

 	}

 	id0 := createNetwork(c, config, true)

 	c.Assert(isNetworkAvailable(c, "br0"), checker.Equals, true)

@@ -86,6 +87,9 @@ func (s *DockerSuite) TestApiNetworkInspect(c *check.C) {

 	c.Assert(nr.IPAM.Config[0].Subnet, checker.Equals, "172.28.0.0/16")

 	c.Assert(nr.IPAM.Config[0].IPRange, checker.Equals, "172.28.5.0/24")

 	c.Assert(nr.IPAM.Config[0].Gateway, checker.Equals, "172.28.5.254")

+	c.Assert(nr.Options["foo"], checker.Equals, "bar")

+	c.Assert(nr.Options["opts"], checker.Equals, "dopts")

+

 	// delete the network and make sure it is deleted

 	deleteNetwork(c, id0, true)

 	c.Assert(isNetworkAvailable(c, "br0"), checker.Equals, false)

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

 	"github.com/docker/docker/api/types"

 	"github.com/docker/docker/pkg/integration/checker"

 	"github.com/docker/libnetwork/driverapi"

+	remoteapi "github.com/docker/libnetwork/drivers/remote/api"

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

 	"github.com/go-check/check"

 )

 const dummyNetworkDriver = "dummy-network-driver"

+var remoteDriverNetworkRequest remoteapi.CreateNetworkRequest

+

 func init() {

 	check.Suite(&DockerNetworkSuite{

 		ds: &DockerSuite{},

@@ -57,6 +61,11 @@ func (s *DockerNetworkSuite) SetUpSuite(c *check.C) {

 	})

 	mux.HandleFunc(fmt.Sprintf("/%s.CreateNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {

+		err := json.NewDecoder(r.Body).Decode(&remoteDriverNetworkRequest)

+		if err != nil {

+			http.Error(w, "Unable to decode JSON payload: "+err.Error(), http.StatusBadRequest)

+			return

+		}

 		w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json")

 		fmt.Fprintf(w, "null")

 	})

@@ -256,3 +265,16 @@ func (s *DockerNetworkSuite) TestDockerNetworkIpamInvalidCombinations(c *check.C

 	c.Assert(err, check.NotNil)

 	dockerCmd(c, "network", "rm", "test0")

 }

+

+func (s *DockerNetworkSuite) TestDockerNetworkDriverOptions(c *check.C) {

+	dockerCmd(c, "network", "create", "-d", dummyNetworkDriver, "-o", "opt1=drv1", "-o", "opt2=drv2", "testopt")

+	assertNwIsAvailable(c, "testopt")

+	gopts := remoteDriverNetworkRequest.Options[netlabel.GenericData]

+	c.Assert(gopts, checker.NotNil)

+	opts, ok := gopts.(map[string]interface{})

+	c.Assert(ok, checker.Equals, true)

+	c.Assert(opts["opt1"], checker.Equals, "drv1")

+	c.Assert(opts["opt2"], checker.Equals, "drv2")

+	dockerCmd(c, "network", "rm", "testopt")

+

+}