package main import ( "errors" "fmt" "os/exec" "strings" "go.fd.io/govpp/binapi/ethernet_types" "go.fd.io/govpp/binapi/interface_types" "go.fd.io/govpp/binapi/ip_types" ) type ( Cmd = exec.Cmd MacAddress = ethernet_types.MacAddress AddressWithPrefix = ip_types.AddressWithPrefix IP4AddressWithPrefix = ip_types.IP4AddressWithPrefix InterfaceIndex = interface_types.InterfaceIndex NetConfig interface { Configure() error Unconfigure() Name() string Type() string } NetConfigBase struct { name string category string // what else to call this when `type` is reserved? } NetInterface struct { NetConfigBase addresser *Addresser ip4Address string // this will have form 10.10.10.1/24 index InterfaceIndex hwAddress MacAddress networkNamespace string networkNumber int peer *NetInterface } NetworkNamespace struct { NetConfigBase } NetworkBridge struct { NetConfigBase networkNamespace string interfaces []string } ) const ( NetNs string = "netns" Veth string = "veth" Tap string = "tap" Bridge string = "bridge" ) type InterfaceAdder func(n *NetInterface) *Cmd var ( ipCommandMap = map[string]InterfaceAdder{ Veth: func(n *NetInterface) *Cmd { return exec.Command("ip", "link", "add", n.name, "type", "veth", "peer", "name", n.peer.name) }, Tap: func(n *NetInterface) *Cmd { return exec.Command("ip", "tuntap", "add", n.name, "mode", "tap") }, } ) func NewNetworkInterface(cfg NetDevConfig, a *Addresser) (*NetInterface, error) { var newInterface *NetInterface = &NetInterface{} var err error newInterface.addresser = a newInterface.name = cfg["name"].(string) newInterface.networkNumber = defaultNetworkNumber if interfaceType, ok := cfg["type"]; ok { newInterface.category = interfaceType.(string) } if presetHwAddress, ok := cfg["preset-hw-address"]; ok { newInterface.hwAddress, err = ethernet_types.ParseMacAddress(presetHwAddress.(string)) if err != nil { return &NetInterface{}, err } } if netns, ok := cfg["netns"]; ok { newInterface.networkNamespace = netns.(string) } if ip, ok := cfg["ip4"]; ok { if n, ok := ip.(NetDevConfig)["network"]; ok { newInterface.networkNumber = n.(int) } newInterface.ip4Address, err = newInterface.addresser.NewIp4Address( newInterface.networkNumber, ) if err != nil { return &NetInterface{}, err } } if _, ok := cfg["peer"]; !ok { return newInterface, nil } peer := cfg["peer"].(NetDevConfig) if newInterface.peer, err = NewNetworkInterface(peer, a); err != nil { return &NetInterface{}, err } return newInterface, nil } func (n *NetInterface) ConfigureUpState() error { err := SetDevUp(n.Name(), "") if err != nil { return fmt.Errorf("set link up failed: %v", err) } return nil } func (n *NetInterface) ConfigureNetworkNamespace() error { if n.networkNamespace != "" { err := LinkSetNetns(n.name, n.networkNamespace) if err != nil { return err } } return nil } func (n *NetInterface) ConfigureAddress() error { if n.ip4Address != "" { if err := AddAddress( n.Name(), n.ip4Address, n.networkNamespace, ); err != nil { return err } } return nil } func (n *NetInterface) Configure() error { cmd := ipCommandMap[n.Type()](n) _, err := cmd.CombinedOutput() if err != nil { return fmt.Errorf("creating interface '%v' failed: %v", n.Name(), err) } if err := n.ConfigureUpState(); err != nil { return err } if err := n.ConfigureNetworkNamespace(); err != nil { return err } if err := n.ConfigureAddress(); err != nil { return err } if n.peer != nil && n.peer.name != "" { if err := n.Peer().ConfigureUpState(); err != nil { return err } if err := n.Peer().ConfigureNetworkNamespace(); err != nil { return err } if err := n.Peer().ConfigureAddress(); err != nil { return err } } return nil } func (n *NetInterface) Unconfigure() { DelLink(n.name) } func (n *NetInterface) Name() string { return n.name } func (n *NetInterface) Type() string { return n.category } func (n *NetInterface) SetAddress(address string) { n.ip4Address = address } func (n *NetInterface) SetIndex(index InterfaceIndex) { n.index = index } func (n *NetInterface) Index() InterfaceIndex { return n.index } func (n *NetInterface) AddressWithPrefix() AddressWithPrefix { address, _ := ip_types.ParseAddressWithPrefix(n.ip4Address) return address } func (n *NetInterface) IP4AddressWithPrefix() IP4AddressWithPrefix { ip4Prefix, _ := ip_types.ParseIP4Prefix(n.ip4Address) ip4AddressWithPrefix := ip_types.IP4AddressWithPrefix(ip4Prefix) return ip4AddressWithPrefix } func (n *NetInterface) IP4AddressString() string { return strings.Split(n.ip4Address, "/")[0] } func (n *NetInterface) HwAddress() MacAddress { return n.hwAddress } func (n *NetInterface) Peer() *NetInterface { return n.peer } func (b *NetConfigBase) Name() string { return b.name } func (b *NetConfigBase) Type() string { return b.category } func NewNetNamespace(cfg NetDevConfig) (NetworkNamespace, error) { var networkNamespace NetworkNamespace networkNamespace.name = cfg["name"].(string) networkNamespace.category = NetNs return networkNamespace, nil } func (ns *NetworkNamespace) Configure() error { return addDelNetns(ns.name, true) } func (ns *NetworkNamespace) Unconfigure() { addDelNetns(ns.name, false) } func NewBridge(cfg NetDevConfig) (NetworkBridge, error) { var bridge NetworkBridge bridge.name = cfg["name"].(string) bridge.category = Bridge for _, v := range cfg["interfaces"].([]interface{}) { bridge.interfaces = append(bridge.interfaces, v.(string)) } bridge.networkNamespace = "" if netns, ok := cfg["netns"]; ok { bridge.networkNamespace = netns.(string) } return bridge, nil } func (b *NetworkBridge) Configure() error { return AddBridge(b.name, b.interfaces, b.networkNamespace) } func (b *NetworkBridge) Unconfigure() { DelBridge(b.name, b.networkNamespace) } func DelBridge(brName, ns string) error { err := SetDevDown(brName, ns) if err != err { return err } err = addDelBridge(brName, ns, false) if err != nil { return err } return nil } func SetDevUp(dev, ns string) error { return setDevUpDown(dev, ns, true) } func SetDevDown(dev, ns string) error { return setDevUpDown(dev, ns, false) } func DelLink(ifName string) { cmd := exec.Command("ip", "link", "del", ifName) cmd.Run() } func setDevUpDown(dev, ns string, isUp bool) error { var op string if isUp { op = "up" } else { op = "down" } c := []string{"ip", "link", "set", "dev", dev, op} cmd := appendNetns(c, ns) err := cmd.Run() if err != nil { s := fmt.Sprintf("error bringing %s device %s!", dev, op) return errors.New(s) } return nil } func addDelNetns(name string, isAdd bool) error { var op string if isAdd { op = "add" } else { op = "del" } cmd := exec.Command("ip", "netns", op, name) _, err := cmd.CombinedOutput() if err != nil { return errors.New("add/del netns failed") } return nil } func AddNetns(nsName string) error { return addDelNetns(nsName, true) } func DelNetns(nsName string) error { return addDelNetns(nsName, false) } func LinkSetNetns(ifName, ns string) error { cmd := exec.Command("ip", "link", "set", "dev", ifName, "up", "netns", ns) err := cmd.Run() if err != nil { return fmt.Errorf("error setting device '%s' to netns '%s: %v", ifName, ns, err) } return nil } func NewCommand(s []string, ns string) *exec.Cmd { return appendNetns(s, ns) } func appendNetns(s []string, ns string) *exec.Cmd { var cmd *exec.Cmd if ns == "" { // use default namespace cmd = exec.Command(s[0], s[1:]...) } else { var args = []string{"netns", "exec", ns} args = append(args, s[:]...) cmd = exec.Command("ip", args...) } return cmd } func addDelBridge(brName, ns string, isAdd bool) error { var op string if isAdd { op = "addbr" } else { op = "delbr" } var c = []string{"brctl", op, brName} cmd := appendNetns(c, ns) err := cmd.Run() if err != nil { s := fmt.Sprintf("%s %s failed!", op, brName) return errors.New(s) } return nil } func AddBridge(brName string, ifs []string, ns string) error { err := addDelBridge(brName, ns, true) if err != nil { return err } for _, v := range ifs { c := []string{"brctl", "addif", brName, v} cmd := appendNetns(c, ns) err = cmd.Run() if err != nil { s := fmt.Sprintf("error adding %s to bridge %s: %v", v, brName, err) return errors.New(s) } } err = SetDevUp(brName, ns) if err != nil { return err } return nil }