github.com/pwn-term/docker@v0.0.0-20210616085119-6e977cce2565/libnetwork/drivers/bridge/interface.go (about)

     1  package bridge
     2  
     3  import (
     4  	"fmt"
     5  	"net"
     6  
     7  	"github.com/sirupsen/logrus"
     8  	"github.com/vishvananda/netlink"
     9  )
    10  
    11  const (
    12  	// DefaultBridgeName is the default name for the bridge interface managed
    13  	// by the driver when unspecified by the caller.
    14  	DefaultBridgeName = "docker0"
    15  )
    16  
    17  // Interface models the bridge network device.
    18  type bridgeInterface struct {
    19  	Link        netlink.Link
    20  	bridgeIPv4  *net.IPNet
    21  	bridgeIPv6  *net.IPNet
    22  	gatewayIPv4 net.IP
    23  	gatewayIPv6 net.IP
    24  	nlh         *netlink.Handle
    25  }
    26  
    27  // newInterface creates a new bridge interface structure. It attempts to find
    28  // an already existing device identified by the configuration BridgeName field,
    29  // or the default bridge name when unspecified, but doesn't attempt to create
    30  // one when missing
    31  func newInterface(nlh *netlink.Handle, config *networkConfiguration) (*bridgeInterface, error) {
    32  	var err error
    33  	i := &bridgeInterface{nlh: nlh}
    34  
    35  	// Initialize the bridge name to the default if unspecified.
    36  	if config.BridgeName == "" {
    37  		config.BridgeName = DefaultBridgeName
    38  	}
    39  
    40  	// Attempt to find an existing bridge named with the specified name.
    41  	i.Link, err = nlh.LinkByName(config.BridgeName)
    42  	if err != nil {
    43  		logrus.Debugf("Did not find any interface with name %s: %v", config.BridgeName, err)
    44  	} else if _, ok := i.Link.(*netlink.Bridge); !ok {
    45  		return nil, fmt.Errorf("existing interface %s is not a bridge", i.Link.Attrs().Name)
    46  	}
    47  	return i, nil
    48  }
    49  
    50  // exists indicates if the existing bridge interface exists on the system.
    51  func (i *bridgeInterface) exists() bool {
    52  	return i.Link != nil
    53  }
    54  
    55  // addresses returns all IPv4 addresses and all IPv6 addresses for the bridge interface.
    56  func (i *bridgeInterface) addresses() ([]netlink.Addr, []netlink.Addr, error) {
    57  	v4addr, err := i.nlh.AddrList(i.Link, netlink.FAMILY_V4)
    58  	if err != nil {
    59  		return nil, nil, fmt.Errorf("Failed to retrieve V4 addresses: %v", err)
    60  	}
    61  
    62  	v6addr, err := i.nlh.AddrList(i.Link, netlink.FAMILY_V6)
    63  	if err != nil {
    64  		return nil, nil, fmt.Errorf("Failed to retrieve V6 addresses: %v", err)
    65  	}
    66  
    67  	if len(v4addr) == 0 {
    68  		return nil, v6addr, nil
    69  	}
    70  	return v4addr, v6addr, nil
    71  }
    72  
    73  func (i *bridgeInterface) programIPv6Address() error {
    74  	_, nlAddressList, err := i.addresses()
    75  	if err != nil {
    76  		return &IPv6AddrAddError{IP: i.bridgeIPv6, Err: fmt.Errorf("failed to retrieve address list: %v", err)}
    77  	}
    78  	nlAddr := netlink.Addr{IPNet: i.bridgeIPv6}
    79  	if findIPv6Address(nlAddr, nlAddressList) {
    80  		return nil
    81  	}
    82  	if err := i.nlh.AddrAdd(i.Link, &nlAddr); err != nil {
    83  		return &IPv6AddrAddError{IP: i.bridgeIPv6, Err: err}
    84  	}
    85  	return nil
    86  }