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 (
AddressWithPrefix = ip_types.AddressWithPrefix
MacAddress = ethernet_types.MacAddress
NetConfig struct {
Configure func() error
Unconfigure func()
}
NetTopology []NetConfig
NetConfigBase struct {
name string
category string // what else to call this when `type` is reserved?
}
NetworkInterfaceVeth struct {
NetConfigBase
index interface_types.InterfaceIndex
peerNetworkNamespace string
peerName string
peerIp4Address string
ip4Address ip_types.AddressWithPrefix
hwAddress ethernet_types.MacAddress
}
NetworkInterfaceTap struct {
NetConfigBase
index interface_types.InterfaceIndex
ip4Address string
}
NetworkNamespace struct {
NetConfigBase
}
NetworkBridge struct {
NetConfigBase
networkNamespace string
interfaces []string
}
)
const (
NetNs string = "netns"
Veth string = "veth"
Tap string = "tap"
Bridge string = "bridge"
)
func (b NetConfigBase) Name() string {
return b.name
}
func (b NetConfigBase) Type() string {
return b.category
}
func (iface NetworkInterfaceVeth) Configure() error {
err := AddVethPair(iface.name, iface.peerName)
if err != nil {
return err
}
if iface.peerNetworkNamespace != "" {
err := LinkSetNetns(iface.peerName, iface.peerNetworkNamespace)
if err != nil {
return err
}
}
if iface.peerIp4Address != "" {
err = AddAddress(iface.peerName, iface.peerIp4Address, iface.peerNetworkNamespace)
if err != nil {
return fmt.Errorf("failed to add configure address for %s: %v", iface.peerName, err)
}
}
return nil
}
func (iface NetworkInterfaceVeth) Unconfigure() {
DelLink(iface.name)
}
func (iface NetworkInterfaceVeth) Address() string {
return strings.Split(iface.ip4Address.String(), "/")[0]
}
func (iface NetworkInterfaceTap) Configure() error {
err := AddTap(iface.name, iface.ip4Address)
if err != nil {
return err
}
return nil
}
func (iface NetworkInterfaceTap) Unconfigure() {
DelLink(iface.name)
}
func (ns NetworkNamespace) Configure() error {
return addDelNetns(ns.name, true)
}
func (ns NetworkNamespace) Unconfigure() {
addDelNetns(ns.name, false)
}
func (b NetworkBridge) Configure() error {
return AddBridge(b.name, b.interfaces, b.networkNamespace)
}
func (b NetworkBridge) Unconfigure() {
DelBridge(b.name, b.networkNamespace)
}
func (t *NetTopology) Configure() error {
for _, c := range *t {
err := c.Configure()
if err != nil {
return err
}
}
return nil
}
func (t *NetTopology) Unconfigure() {
for _, c := range *t {
c.Unconfigure()
}
}
func newConfigFn(cfg NetDevConfig) func() error {
t := cfg["type"]
if t == "netns" {
return func() error { return AddNetns(cfg["name"].(string)) }
} else if t == "veth" {
return func() error {
var peerNs string
peer := cfg["peer"].(NetDevConfig)
peerName := peer["name"].(string)
err := AddVethPair(cfg["name"].(string), peerName)
if err != nil {
return err
}
if peer["netns"] != nil {
peerNs = peer["netns"].(string)
if peerNs != "" {
err := LinkSetNetns(peerName, peerNs)
if err != nil {
return err
}
}
}
if peer["ip4"] != nil {
err = AddAddress(peerName, peer["ip4"].(string), peerNs)
if err != nil {
return fmt.Errorf("failed to add configure address for %s: %v", peerName, err)
}
}
return nil
}
} else if t == "bridge" {
return func() error { return configureBridge(cfg) }
} else if t == "tap" {
return func() error { return configureTap(cfg) }
}
return nil
}
func newUnconfigFn(cfg NetDevConfig) func() {
t := cfg["type"]
name := cfg["name"].(string)
if t == "tap" {
return func() { DelLink(name) }
} else if t == "netns" {
return func() { DelNetns(name) }
} else if t == "veth" {
return func() { DelLink(name) }
} else if t == "bridge" {
return func() { DelBridge(name, cfg["netns"].(string)) }
}
return nil
}
func NewNetConfig(cfg NetDevConfig) NetConfig {
var nc NetConfig
nc.Configure = newConfigFn(cfg)
nc.Unconfigure = newUnconfigFn(cfg)
return nc
}
func NewNetNamespace(cfg NetDevConfig) (NetworkNamespace, error) {
var networkNamespace NetworkNamespace
networkNamespace.name = cfg["name"].(string)
networkNamespace.category = "netns"
return networkNamespace, nil
}
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 = cfg["netns"].(string)
return bridge, nil
}
func NewVeth(cfg NetDevConfig) (NetworkInterfaceVeth, error) {
var veth NetworkInterfaceVeth
var err error
veth.name = cfg["name"].(string)
veth.category = "veth"
if cfg["preset-hw-address"] != nil {
veth.hwAddress, err = ethernet_types.ParseMacAddress(cfg["preset-hw-address"].(string))
if err != nil {
return NetworkInterfaceVeth{}, err
}
}
peer := cfg["peer"].(NetDevConfig)
veth.peerName = peer["name"].(string)
if peer["netns"] != nil {
veth.peerNetworkNamespace = peer["netns"].(string)
}
if peer["ip4"] != nil {
veth.peerIp4Address = peer["ip4"].(string)
}
return veth, nil
}
func NewTap(cfg NetDevConfig) (NetworkInterfaceTap, error) {
var tap NetworkInterfaceTap
tap.name = cfg["name"].(string)
tap.category = "tap"
tap.ip4Address = cfg["ip4"].(string)
return tap, nil
}
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 configureBridge(dev NetDevConfig) error {
var ifs []string
for _, v := range dev["interfaces"].([]interface{}) {
ifs = append(ifs, v.(string))
}
return AddBridge(dev["name"].(string), ifs, dev["netns"].(string))
}
func configureTap(dev NetDevConfig) error {
return AddTap(dev["name"].(string), dev["ip4"].(string))
}
func SetDevUp(dev, ns string) error {
return setDevUpDown(dev, ns, true)
}
func SetDevDown(dev, ns string) error {
return setDevUpDown(dev, ns, false)
}
func AddTap(ifName, ifAddress string) error {
cmd := exec.Command("ip", "tuntap", "add", ifName, "mode", "tap")
o, err := cmd.CombinedOutput()
if err != nil {
s := fmt.Sprintf("error creating tap %s: %v: %s", ifName, err, string(o))
return errors.New(s)
}
cmd = exec.Command("ip", "addr", "add", ifAddress, "dev", ifName)
err = cmd.Run()
if err != nil {
DelLink(ifName)
s := fmt.Sprintf("error setting addr for tap %s: %v", ifName, err)
return errors.New(s)
}
err = SetDevUp(ifName, "")
if err != nil {
DelLink(ifName)
return err
}
return nil
}
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 AddVethPair(ifName, peerName string) error {
cmd := exec.Command("ip", "link", "add", ifName, "type", "veth", "peer", "name", peerName)
err := cmd.Run()
if err != nil {
return fmt.Errorf("creating veth pair failed: %v", err)
}
err = SetDevUp(ifName, "")
if err != nil {
return fmt.Errorf("set link up failed: %v", err)
}
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
}
