// FIXME(thaJeztah): remove once we are a module; the go:build directive prevents go from downgrading language version to go1.16:

//go:build go1.21

package libnetwork

import (

"context"

"encoding/json"

"fmt"

"net"

"net/netip"

"runtime"

"strings"

"sync"

"time"

"github.com/containerd/log"

"github.com/docker/docker/libnetwork/datastore"

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

"github.com/docker/docker/libnetwork/etchosts"

"github.com/docker/docker/libnetwork/internal/netiputil"

"github.com/docker/docker/libnetwork/internal/setmatrix"

"github.com/docker/docker/libnetwork/ipamapi"

"github.com/docker/docker/libnetwork/ipams/defaultipam"

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

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

"github.com/docker/docker/libnetwork/networkdb"

"github.com/docker/docker/libnetwork/options"

"github.com/docker/docker/libnetwork/scope"

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

"github.com/docker/docker/pkg/stringid"

"go.opentelemetry.io/otel"

"go.opentelemetry.io/otel/attribute"

"go.opentelemetry.io/otel/trace"

)

// EndpointWalker is a client provided function which will be used to walk the Endpoints.

// When the function returns true, the walk will stop.

type EndpointWalker func(ep *Endpoint) bool

// ipInfo is the reverse mapping from IP to service name to serve the PTR query.

// extResolver is set if an external server resolves a service name to this IP.

// It's an indication to defer PTR queries also to that external server.

type ipInfo struct {

name string

serviceID string

extResolver bool

}

// svcMapEntry is the body of the element into the svcMap

// The ip is a string because the SetMatrix does not accept non hashable values

type svcMapEntry struct {

ip string

serviceID string

}

type svcInfo struct {

svcMap setmatrix.SetMatrix[svcMapEntry]

svcIPv6Map setmatrix.SetMatrix[svcMapEntry]

ipMap setmatrix.SetMatrix[ipInfo]

service map[string][]servicePorts

}

// backing container or host's info

type serviceTarget struct {

name string

ip net.IP

port uint16

}

type servicePorts struct {

portName string

proto string

target []serviceTarget

}

type networkDBTable struct {

name string

objType driverapi.ObjectType

}

// IpamConf contains all the ipam related configurations for a network

//

// TODO(aker): use proper net/* structs instead of string literals.

type IpamConf struct {

// PreferredPool is the master address pool for containers and network interfaces.

PreferredPool string

// SubPool is a subset of the master pool. If specified,

// this becomes the container pool for automatic address allocations.

SubPool string

// Gateway is the preferred Network Gateway address (optional).

Gateway string

// AuxAddresses contains auxiliary addresses for network driver. Must be within the master pool.

// libnetwork will reserve them if they fall into the container pool.

AuxAddresses map[string]string

}

// Validate checks whether the configuration is valid

func (c *IpamConf) Validate() error {

if c.Gateway != "" && nil == net.ParseIP(c.Gateway) {

return types.InvalidParameterErrorf("invalid gateway address %s in Ipam configuration", c.Gateway)

}

return nil

}

// Contains checks whether the ipam master address pool contains [addr].

func (c *IpamConf) Contains(addr net.IP) bool {

if c == nil {

return false

}

if c.PreferredPool == "" {

return false

}

_, allowedRange, _ := net.ParseCIDR(c.PreferredPool)

return allowedRange.Contains(addr)

}

// IsStatic checks whether the subnet was statically allocated (ie. user-defined).

func (c *IpamConf) IsStatic() bool {

return c != nil && c.PreferredPool != ""

}

// IpamInfo contains all the ipam related operational info for a network

type IpamInfo struct {

PoolID string

Meta map[string]string

driverapi.IPAMData

}

// MarshalJSON encodes IpamInfo into json message

func (i *IpamInfo) MarshalJSON() ([]byte, error) {

m := map[string]interface{}{

"PoolID": i.PoolID,

}

v, err := json.Marshal(&i.IPAMData)

if err != nil {

return nil, err

}

m["IPAMData"] = string(v)

if i.Meta != nil {

m["Meta"] = i.Meta

}

return json.Marshal(m)

}

// UnmarshalJSON decodes json message into PoolData

func (i *IpamInfo) UnmarshalJSON(data []byte) error {

var (

m map[string]interface{}

err error

)

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

return err

}

i.PoolID = m["PoolID"].(string)

if v, ok := m["Meta"]; ok {

b, _ := json.Marshal(v)

if err = json.Unmarshal(b, &i.Meta); err != nil {

return err

}

}

if v, ok := m["IPAMData"]; ok {

if err = json.Unmarshal([]byte(v.(string)), &i.IPAMData); err != nil {

return err

}

}

return nil

}

// Network represents a logical connectivity zone that containers may

// join using the Link method. A network is managed by a specific driver.

type Network struct {

ctrlr *Controller

name string

networkType string // networkType is the name of the netdriver used by this network

id string

created time.Time

scope string // network data scope

labels map[string]string

ipamType string // ipamType is the name of the IPAM driver

ipamOptions map[string]string

addrSpace string

ipamV4Config []*IpamConf

ipamV6Config []*IpamConf

ipamV4Info []*IpamInfo

ipamV6Info []*IpamInfo

enableIPv4 bool

enableIPv6 bool

postIPv6 bool

epCnt *endpointCnt

generic options.Generic

dbIndex uint64

dbExists bool

persist bool

drvOnce *sync.Once

resolver []*Resolver

internal bool

attachable bool

inDelete bool

ingress bool

driverTables []networkDBTable

dynamic bool

configOnly bool

configFrom string

loadBalancerIP net.IP

loadBalancerMode string

platformNetwork //nolint:nolintlint,unused // only populated on windows

mu sync.Mutex

}

const (

loadBalancerModeNAT = "NAT"

loadBalancerModeDSR = "DSR"

loadBalancerModeDefault = loadBalancerModeNAT

)

// Name returns a user chosen name for this network.

func (n *Network) Name() string {

n.mu.Lock()

defer n.mu.Unlock()

return n.name

}

// ID returns a system generated id for this network.

func (n *Network) ID() string {

n.mu.Lock()

defer n.mu.Unlock()

return n.id

}

func (n *Network) Created() time.Time {

n.mu.Lock()

defer n.mu.Unlock()

return n.created

}

// Type returns the type of network, which corresponds to its managing driver.

func (n *Network) Type() string {

n.mu.Lock()

defer n.mu.Unlock()

return n.networkType

}

func (n *Network) Resolvers() []*Resolver {

n.mu.Lock()

defer n.mu.Unlock()

return n.resolver

}

func (n *Network) Key() []string {

n.mu.Lock()

defer n.mu.Unlock()

return []string{datastore.NetworkKeyPrefix, n.id}

}

func (n *Network) KeyPrefix() []string {

return []string{datastore.NetworkKeyPrefix}

}

func (n *Network) Value() []byte {

n.mu.Lock()

defer n.mu.Unlock()

b, err := json.Marshal(n)

if err != nil {

return nil

}

return b

}

func (n *Network) SetValue(value []byte) error {

return json.Unmarshal(value, n)

}

func (n *Network) Index() uint64 {

n.mu.Lock()

defer n.mu.Unlock()

return n.dbIndex

}

func (n *Network) SetIndex(index uint64) {

n.mu.Lock()

n.dbIndex = index

n.dbExists = true

n.mu.Unlock()

}

func (n *Network) Exists() bool {

n.mu.Lock()

defer n.mu.Unlock()

return n.dbExists

}

func (n *Network) Skip() bool {

n.mu.Lock()

defer n.mu.Unlock()

return !n.persist

}

func (n *Network) New() datastore.KVObject {

n.mu.Lock()

defer n.mu.Unlock()

return &Network{

ctrlr: n.ctrlr,

drvOnce: &sync.Once{},

scope: n.scope,

}

}

// CopyTo deep copies to the destination IpamConfig

func (c *IpamConf) CopyTo(dstC *IpamConf) error {

dstC.PreferredPool = c.PreferredPool

dstC.SubPool = c.SubPool

dstC.Gateway = c.Gateway

if c.AuxAddresses != nil {

dstC.AuxAddresses = make(map[string]string, len(c.AuxAddresses))

for k, v := range c.AuxAddresses {

dstC.AuxAddresses[k] = v

}

}

return nil

}

// CopyTo deep copies to the destination IpamInfo

func (i *IpamInfo) CopyTo(dstI *IpamInfo) error {

dstI.PoolID = i.PoolID

if i.Meta != nil {

dstI.Meta = make(map[string]string)

for k, v := range i.Meta {

dstI.Meta[k] = v

}

}

dstI.AddressSpace = i.AddressSpace

dstI.Pool = types.GetIPNetCopy(i.Pool)

dstI.Gateway = types.GetIPNetCopy(i.Gateway)

if i.AuxAddresses != nil {

dstI.AuxAddresses = make(map[string]*net.IPNet)

for k, v := range i.AuxAddresses {

dstI.AuxAddresses[k] = types.GetIPNetCopy(v)

}

}

return nil

}

func (n *Network) validateConfiguration() error {

if n.configOnly {

// Only supports network specific configurations.

// Network operator configurations are not supported.

if n.ingress || n.internal || n.attachable || n.scope != "" {

return types.ForbiddenErrorf("configuration network can only contain network " +

"specific fields. Network operator fields like " +

"[ ingress | internal | attachable | scope ] are not supported.")

}

}

if n.configFrom != "" {

if n.configOnly {

return types.ForbiddenErrorf("a configuration network cannot depend on another configuration network")

}

if n.ipamType != "" &&

n.ipamType != defaultIpamForNetworkType(n.networkType) ||

n.enableIPv4 || n.enableIPv6 ||

len(n.labels) > 0 || len(n.ipamOptions) > 0 ||

len(n.ipamV4Config) > 0 || len(n.ipamV6Config) > 0 {

return types.ForbiddenErrorf("user specified configurations are not supported if the network depends on a configuration network")

}

if len(n.generic) > 0 {

if data, ok := n.generic[netlabel.GenericData]; ok {

var (

driverOptions map[string]string

opts interface{}

)

switch t := data.(type) {

case map[string]interface{}, map[string]string:

opts = t

}

ba, err := json.Marshal(opts)

if err != nil {

return fmt.Errorf("failed to validate network configuration: %v", err)

}

if err := json.Unmarshal(ba, &driverOptions); err != nil {

return fmt.Errorf("failed to validate network configuration: %v", err)

}

if len(driverOptions) > 0 {

return types.ForbiddenErrorf("network driver options are not supported if the network depends on a configuration network")

}

}

}

}

return nil

}

// applyConfigurationTo applies network specific configurations.

func (n *Network) applyConfigurationTo(to *Network) error {

to.enableIPv4 = n.enableIPv4

to.enableIPv6 = n.enableIPv6

if len(n.labels) > 0 {

to.labels = make(map[string]string, len(n.labels))

for k, v := range n.labels {

if _, ok := to.labels[k]; !ok {

to.labels[k] = v

}

}

}

if len(n.ipamType) != 0 {

to.ipamType = n.ipamType

}

if len(n.ipamOptions) > 0 {

to.ipamOptions = make(map[string]string, len(n.ipamOptions))

for k, v := range n.ipamOptions {

if _, ok := to.ipamOptions[k]; !ok {

to.ipamOptions[k] = v

}

}

}

if len(n.ipamV4Config) > 0 {

to.ipamV4Config = make([]*IpamConf, 0, len(n.ipamV4Config))

to.ipamV4Config = append(to.ipamV4Config, n.ipamV4Config...)

}

if len(n.ipamV6Config) > 0 {

to.ipamV6Config = make([]*IpamConf, 0, len(n.ipamV6Config))

to.ipamV6Config = append(to.ipamV6Config, n.ipamV6Config...)

}

if len(n.generic) > 0 {

to.generic = options.Generic{}

for k, v := range n.generic {

to.generic[k] = v

}

}

return nil

}

func (n *Network) CopyTo(o datastore.KVObject) error {

n.mu.Lock()

defer n.mu.Unlock()

dstN := o.(*Network)

dstN.name = n.name

dstN.id = n.id

dstN.created = n.created

dstN.networkType = n.networkType

dstN.scope = n.scope

dstN.dynamic = n.dynamic

dstN.ipamType = n.ipamType

dstN.enableIPv4 = n.enableIPv4

dstN.enableIPv6 = n.enableIPv6

dstN.persist = n.persist

dstN.postIPv6 = n.postIPv6

dstN.dbIndex = n.dbIndex

dstN.dbExists = n.dbExists

dstN.drvOnce = n.drvOnce

dstN.internal = n.internal

dstN.attachable = n.attachable

dstN.inDelete = n.inDelete

dstN.ingress = n.ingress

dstN.configOnly = n.configOnly

dstN.configFrom = n.configFrom

dstN.loadBalancerIP = n.loadBalancerIP

dstN.loadBalancerMode = n.loadBalancerMode

// copy labels

if dstN.labels == nil {

dstN.labels = make(map[string]string, len(n.labels))

}

for k, v := range n.labels {

dstN.labels[k] = v

}

if n.ipamOptions != nil {

dstN.ipamOptions = make(map[string]string, len(n.ipamOptions))

for k, v := range n.ipamOptions {

dstN.ipamOptions[k] = v

}

}

for _, v4conf := range n.ipamV4Config {

dstV4Conf := &IpamConf{}

if err := v4conf.CopyTo(dstV4Conf); err != nil {

return err

}

dstN.ipamV4Config = append(dstN.ipamV4Config, dstV4Conf)

}

for _, v4info := range n.ipamV4Info {

dstV4Info := &IpamInfo{}

if err := v4info.CopyTo(dstV4Info); err != nil {

return err

}

dstN.ipamV4Info = append(dstN.ipamV4Info, dstV4Info)

}

for _, v6conf := range n.ipamV6Config {

dstV6Conf := &IpamConf{}

if err := v6conf.CopyTo(dstV6Conf); err != nil {

return err

}

dstN.ipamV6Config = append(dstN.ipamV6Config, dstV6Conf)

}

for _, v6info := range n.ipamV6Info {

dstV6Info := &IpamInfo{}

if err := v6info.CopyTo(dstV6Info); err != nil {

return err

}

dstN.ipamV6Info = append(dstN.ipamV6Info, dstV6Info)

}

dstN.generic = options.Generic{}

for k, v := range n.generic {

dstN.generic[k] = v

}

return nil

}

func (n *Network) getEpCnt() *endpointCnt {

n.mu.Lock()

defer n.mu.Unlock()

return n.epCnt

}

// TODO : Can be made much more generic with the help of reflection (but has some golang limitations)

func (n *Network) MarshalJSON() ([]byte, error) {

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

netMap["name"] = n.name

netMap["id"] = n.id

netMap["created"] = n.created

netMap["networkType"] = n.networkType

netMap["scope"] = n.scope

netMap["labels"] = n.labels

netMap["ipamType"] = n.ipamType

netMap["ipamOptions"] = n.ipamOptions

netMap["addrSpace"] = n.addrSpace

netMap["enableIPv4"] = n.enableIPv4

netMap["enableIPv6"] = n.enableIPv6

if n.generic != nil {

netMap["generic"] = n.generic

}

netMap["persist"] = n.persist

netMap["postIPv6"] = n.postIPv6

if len(n.ipamV4Config) > 0 {

ics, err := json.Marshal(n.ipamV4Config)

if err != nil {

return nil, err

}

netMap["ipamV4Config"] = string(ics)

}

if len(n.ipamV4Info) > 0 {

iis, err := json.Marshal(n.ipamV4Info)

if err != nil {

return nil, err

}

netMap["ipamV4Info"] = string(iis)

}

if len(n.ipamV6Config) > 0 {

ics, err := json.Marshal(n.ipamV6Config)

if err != nil {

return nil, err

}

netMap["ipamV6Config"] = string(ics)

}

if len(n.ipamV6Info) > 0 {

iis, err := json.Marshal(n.ipamV6Info)

if err != nil {

return nil, err

}

netMap["ipamV6Info"] = string(iis)

}

netMap["internal"] = n.internal

netMap["attachable"] = n.attachable

netMap["inDelete"] = n.inDelete

netMap["ingress"] = n.ingress

netMap["configOnly"] = n.configOnly

netMap["configFrom"] = n.configFrom

netMap["loadBalancerIP"] = n.loadBalancerIP

netMap["loadBalancerMode"] = n.loadBalancerMode

return json.Marshal(netMap)

}

// TODO : Can be made much more generic with the help of reflection (but has some golang limitations)

func (n *Network) UnmarshalJSON(b []byte) (err error) {

var netMap map[string]interface{}

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

return err

}

n.name = netMap["name"].(string)

n.id = netMap["id"].(string)

// "created" is not available in older versions

if v, ok := netMap["created"]; ok {

// n.created is time.Time but marshalled as string

if err = n.created.UnmarshalText([]byte(v.(string))); err != nil {

log.G(context.TODO()).Warnf("failed to unmarshal creation time %v: %v", v, err)

n.created = time.Time{}

}

}

n.networkType = netMap["networkType"].(string)

if v, ok := netMap["enableIPv4"]; ok {

n.enableIPv4 = v.(bool)

} else {

// Set enableIPv4 for IPv4 networks created before the option was added.

_, n.enableIPv4 = netMap["ipamV4Info"]

}

n.enableIPv6 = netMap["enableIPv6"].(bool)

// if we weren't unmarshaling to netMap we could simply set n.labels

// unfortunately, we can't because map[string]interface{} != map[string]string

if labels, ok := netMap["labels"].(map[string]interface{}); ok {

n.labels = make(map[string]string, len(labels))

for label, value := range labels {

n.labels[label] = value.(string)

}

}

if v, ok := netMap["ipamOptions"]; ok {

if iOpts, ok := v.(map[string]interface{}); ok {

n.ipamOptions = make(map[string]string, len(iOpts))

for k, v := range iOpts {

n.ipamOptions[k] = v.(string)

}

}

}

if v, ok := netMap["generic"]; ok {

n.generic = v.(map[string]interface{})

// Restore opts in their map[string]string form

if v, ok := n.generic[netlabel.GenericData]; ok {

var lmap map[string]string

ba, err := json.Marshal(v)

if err != nil {

return err

}

if err := json.Unmarshal(ba, &lmap); err != nil {

return err

}

n.generic[netlabel.GenericData] = lmap

}

}

if v, ok := netMap["persist"]; ok {

n.persist = v.(bool)

}

if v, ok := netMap["postIPv6"]; ok {

n.postIPv6 = v.(bool)

}

if v, ok := netMap["ipamType"]; ok {

n.ipamType = v.(string)

} else {

n.ipamType = defaultipam.DriverName

}

if v, ok := netMap["addrSpace"]; ok {

n.addrSpace = v.(string)

}

if v, ok := netMap["ipamV4Config"]; ok {

if err := json.Unmarshal([]byte(v.(string)), &n.ipamV4Config); err != nil {

return err

}

}

if v, ok := netMap["ipamV4Info"]; ok {

if err := json.Unmarshal([]byte(v.(string)), &n.ipamV4Info); err != nil {

return err

}

}

if v, ok := netMap["ipamV6Config"]; ok {

if err := json.Unmarshal([]byte(v.(string)), &n.ipamV6Config); err != nil {

return err

}

}

if v, ok := netMap["ipamV6Info"]; ok {

if err := json.Unmarshal([]byte(v.(string)), &n.ipamV6Info); err != nil {

return err

}

}

if v, ok := netMap["internal"]; ok {

n.internal = v.(bool)

}

if v, ok := netMap["attachable"]; ok {

n.attachable = v.(bool)

}

if s, ok := netMap["scope"]; ok {

n.scope = s.(string)

}

if v, ok := netMap["inDelete"]; ok {

n.inDelete = v.(bool)

}

if v, ok := netMap["ingress"]; ok {

n.ingress = v.(bool)

}

if v, ok := netMap["configOnly"]; ok {

n.configOnly = v.(bool)

}

if v, ok := netMap["configFrom"]; ok {

n.configFrom = v.(string)

}

if v, ok := netMap["loadBalancerIP"]; ok {

n.loadBalancerIP = net.ParseIP(v.(string))

}

n.loadBalancerMode = loadBalancerModeDefault

if v, ok := netMap["loadBalancerMode"]; ok {

n.loadBalancerMode = v.(string)

}

return nil

}

// NetworkOption is an option setter function type used to pass various options to

// NewNetwork method. The various setter functions of type NetworkOption are

// provided by libnetwork, they look like NetworkOptionXXXX(...)

type NetworkOption func(n *Network)

// NetworkOptionGeneric function returns an option setter for a Generic option defined

// in a Dictionary of Key-Value pair

func NetworkOptionGeneric(generic map[string]interface{}) NetworkOption {

return func(n *Network) {

if n.generic == nil {

n.generic = make(map[string]interface{})

}

if val, ok := generic[netlabel.EnableIPv4]; ok {

n.enableIPv4 = val.(bool)

}

if val, ok := generic[netlabel.EnableIPv6]; ok {

n.enableIPv6 = val.(bool)

}

if val, ok := generic[netlabel.Internal]; ok {

n.internal = val.(bool)

}

for k, v := range generic {

n.generic[k] = v

}

}

}

// NetworkOptionIngress returns an option setter to indicate if a network is

// an ingress network.

func NetworkOptionIngress(ingress bool) NetworkOption {

return func(n *Network) {

n.ingress = ingress

}

}

// NetworkOptionPersist returns an option setter to set persistence policy for a network

func NetworkOptionPersist(persist bool) NetworkOption {

return func(n *Network) {

n.persist = persist

}

}

// NetworkOptionEnableIPv4 returns an option setter to explicitly configure IPv4

func NetworkOptionEnableIPv4(enableIPv4 bool) NetworkOption {

return func(n *Network) {

if n.generic == nil {

n.generic = make(map[string]interface{})

}

n.enableIPv4 = enableIPv4

n.generic[netlabel.EnableIPv4] = enableIPv4

}

}

// NetworkOptionEnableIPv6 returns an option setter to explicitly configure IPv6

func NetworkOptionEnableIPv6(enableIPv6 bool) NetworkOption {

return func(n *Network) {

if n.generic == nil {

n.generic = make(map[string]interface{})

}

n.enableIPv6 = enableIPv6

n.generic[netlabel.EnableIPv6] = enableIPv6

}

}

// NetworkOptionInternalNetwork returns an option setter to config the network

// to be internal which disables default gateway service

func NetworkOptionInternalNetwork() NetworkOption {

return func(n *Network) {

if n.generic == nil {

n.generic = make(map[string]interface{})

}

n.internal = true

n.generic[netlabel.Internal] = true

}

}

// NetworkOptionAttachable returns an option setter to set attachable for a network

func NetworkOptionAttachable(attachable bool) NetworkOption {

return func(n *Network) {

n.attachable = attachable

}

}

// NetworkOptionScope returns an option setter to overwrite the network's scope.

// By default the network's scope is set to the network driver's datascope.

func NetworkOptionScope(scope string) NetworkOption {

return func(n *Network) {

n.scope = scope

}

}

// NetworkOptionIpam function returns an option setter for the ipam configuration for this network

func NetworkOptionIpam(ipamDriver string, addrSpace string, ipV4 []*IpamConf, ipV6 []*IpamConf, opts map[string]string) NetworkOption {

return func(n *Network) {

if ipamDriver != "" {

n.ipamType = ipamDriver

if ipamDriver == defaultipam.DriverName {

n.ipamType = defaultIpamForNetworkType(n.Type())

}

}

n.ipamOptions = opts

n.addrSpace = addrSpace

n.ipamV4Config = ipV4

n.ipamV6Config = ipV6

}

}

// NetworkOptionLBEndpoint function returns an option setter for the configuration of the load balancer endpoint for this network

func NetworkOptionLBEndpoint(ip net.IP) NetworkOption {

return func(n *Network) {

n.loadBalancerIP = ip

}

}

// NetworkOptionDriverOpts function returns an option setter for any driver parameter described by a map

func NetworkOptionDriverOpts(opts map[string]string) NetworkOption {

return func(n *Network) {

if n.generic == nil {

n.generic = make(map[string]interface{})

}

if opts == nil {

opts = make(map[string]string)

}

// Store the options

n.generic[netlabel.GenericData] = opts

}

}

// NetworkOptionLabels function returns an option setter for labels specific to a network

func NetworkOptionLabels(labels map[string]string) NetworkOption {

return func(n *Network) {

n.labels = labels

}

}

// NetworkOptionDynamic function returns an option setter for dynamic option for a network

func NetworkOptionDynamic() NetworkOption {

return func(n *Network) {

n.dynamic = true

}

}

// NetworkOptionDeferIPv6Alloc instructs the network to defer the IPV6 address allocation until after the endpoint has been created

// It is being provided to support the specific docker daemon flags where user can deterministically assign an IPv6 address

// to a container as combination of fixed-cidr-v6 + mac-address

// TODO: Remove this option setter once we support endpoint ipam options

func NetworkOptionDeferIPv6Alloc(enable bool) NetworkOption {

return func(n *Network) {

n.postIPv6 = enable

}

}

// NetworkOptionConfigOnly tells controller this network is

// a configuration only network. It serves as a configuration

// for other networks.

func NetworkOptionConfigOnly() NetworkOption {

return func(n *Network) {

n.configOnly = true

}

}

// NetworkOptionConfigFrom tells controller to pick the

// network configuration from a configuration only network

func NetworkOptionConfigFrom(name string) NetworkOption {

return func(n *Network) {

n.configFrom = name

}

}

func (n *Network) processOptions(options ...NetworkOption) {

for _, opt := range options {

if opt != nil {

opt(n)

}

}

}

type networkDeleteParams struct {

rmLBEndpoint bool

}

// NetworkDeleteOption is a type for optional parameters to pass to the

// Network.Delete() function.

type NetworkDeleteOption func(p *networkDeleteParams)

// NetworkDeleteOptionRemoveLB informs a Network.Delete() operation that should

// remove the load balancer endpoint for this network. Note that the Delete()

// method will automatically remove a load balancing endpoint for most networks

// when the network is otherwise empty. However, this does not occur for some

// networks. In particular, networks marked as ingress (which are supposed to

// be more permanent than other overlay networks) won't automatically remove

// the LB endpoint on Delete(). This method allows for explicit removal of

// such networks provided there are no other endpoints present in the network.

// If the network still has non-LB endpoints present, Delete() will not

// remove the LB endpoint and will return an error.

func NetworkDeleteOptionRemoveLB(p *networkDeleteParams) {

p.rmLBEndpoint = true

}

func (n *Network) resolveDriver(name string, load bool) (driverapi.Driver, driverapi.Capability, error) {

c := n.getController()

// Check if a driver for the specified network type is available

d, capabilities := c.drvRegistry.Driver(name)

if d == nil {

if load {

err := c.loadDriver(name)

if err != nil {

return nil, driverapi.Capability{}, err

}

d, capabilities = c.drvRegistry.Driver(name)

if d == nil {

return nil, driverapi.Capability{}, fmt.Errorf("could not resolve driver %s in registry", name)

}

} else {

// don't fail if driver loading is not required

return nil, driverapi.Capability{}, nil

}

}

return d, capabilities, nil

}

func (n *Network) driverIsMultihost() bool {

_, capabilities, err := n.resolveDriver(n.networkType, true)

if err != nil {

return false

}

return capabilities.ConnectivityScope == scope.Global

}

func (n *Network) driver(load bool) (driverapi.Driver, error) {

d, capabilities, err := n.resolveDriver(n.networkType, load)

if err != nil {

return nil, err

}

n.mu.Lock()

// If load is not required, driver, cap and err may all be nil

if n.scope == "" {

n.scope = capabilities.DataScope

}

if n.dynamic {

// If the network is dynamic, then it is swarm

// scoped regardless of the backing driver.

n.scope = scope.Swarm

}

n.mu.Unlock()

return d, nil

}

// Delete the network.

func (n *Network) Delete(options ...NetworkDeleteOption) error {

var params networkDeleteParams

for _, opt := range options {

opt(&params)

}

return n.delete(false, params.rmLBEndpoint)

}

// This function gets called in 3 ways:

// - Delete() -- (false, false)

// remove if endpoint count == 0 or endpoint count == 1 and

// there is a load balancer IP

// - Delete(libnetwork.NetworkDeleteOptionRemoveLB) -- (false, true)

// remove load balancer and network if endpoint count == 1

// - controller.networkCleanup() -- (true, true)

// remove the network no matter what

func (n *Network) delete(force bool, rmLBEndpoint bool) error {

n.mu.Lock()

c := n.ctrlr

name := n.name

id := n.id

n.mu.Unlock()

c.networkLocker.Lock(id)

defer c.networkLocker.Unlock(id) //nolint:errcheck

n, err := c.getNetworkFromStore(id)

if err != nil {

return &UnknownNetworkError{name: name, id: id}

}

// Only remove ingress on force removal or explicit LB endpoint removal

if n.ingress && !force && !rmLBEndpoint {

return &ActiveEndpointsError{name: n.name, id: n.id}