9 "go.fd.io/govpp/binapi/ethernet_types"
10 "go.fd.io/govpp/binapi/interface_types"
11 "go.fd.io/govpp/binapi/ip_types"
16 MacAddress = ethernet_types.MacAddress
17 AddressWithPrefix = ip_types.AddressWithPrefix
18 IP4AddressWithPrefix = ip_types.IP4AddressWithPrefix
19 InterfaceIndex = interface_types.InterfaceIndex
28 NetConfigBase struct {
30 category string // what else to call this when `type` is reserved?
36 ip4Address string // this will have form 10.10.10.1/24
39 networkNamespace string
44 NetworkNamespace struct {
48 NetworkBridge struct {
50 networkNamespace string
56 NetNs string = "netns"
59 Bridge string = "bridge"
62 type InterfaceAdder func(n *NetInterface) *Cmd
65 ipCommandMap = map[string]InterfaceAdder{
66 Veth: func(n *NetInterface) *Cmd {
67 return exec.Command("ip", "link", "add", n.name, "type", "veth", "peer", "name", n.peer.name)
69 Tap: func(n *NetInterface) *Cmd {
70 return exec.Command("ip", "tuntap", "add", n.name, "mode", "tap")
75 func NewNetworkInterface(cfg NetDevConfig, a *Addresser) (*NetInterface, error) {
76 var newInterface *NetInterface = &NetInterface{}
78 newInterface.addresser = a
79 newInterface.name = cfg["name"].(string)
80 newInterface.networkNumber = defaultNetworkNumber
82 if interfaceType, ok := cfg["type"]; ok {
83 newInterface.category = interfaceType.(string)
86 if presetHwAddress, ok := cfg["preset-hw-address"]; ok {
87 newInterface.hwAddress, err = ethernet_types.ParseMacAddress(presetHwAddress.(string))
89 return &NetInterface{}, err
93 if netns, ok := cfg["netns"]; ok {
94 newInterface.networkNamespace = netns.(string)
97 if ip, ok := cfg["ip4"]; ok {
98 if n, ok := ip.(NetDevConfig)["network"]; ok {
99 newInterface.networkNumber = n.(int)
101 newInterface.ip4Address, err = newInterface.addresser.NewIp4Address(
102 newInterface.networkNumber,
105 return &NetInterface{}, err
109 if _, ok := cfg["peer"]; !ok {
110 return newInterface, nil
113 peer := cfg["peer"].(NetDevConfig)
115 if newInterface.peer, err = NewNetworkInterface(peer, a); err != nil {
116 return &NetInterface{}, err
119 return newInterface, nil
122 func (n *NetInterface) ConfigureUpState() error {
123 err := SetDevUp(n.Name(), "")
125 return fmt.Errorf("set link up failed: %v", err)
130 func (n *NetInterface) ConfigureNetworkNamespace() error {
131 if n.networkNamespace != "" {
132 err := LinkSetNetns(n.name, n.networkNamespace)
140 func (n *NetInterface) ConfigureAddress() error {
141 if n.ip4Address != "" {
142 if err := AddAddress(
154 func (n *NetInterface) Configure() error {
155 cmd := ipCommandMap[n.Type()](n)
156 _, err := cmd.CombinedOutput()
158 return fmt.Errorf("creating interface '%v' failed: %v", n.Name(), err)
161 if err := n.ConfigureUpState(); err != nil {
165 if err := n.ConfigureNetworkNamespace(); err != nil {
169 if err := n.ConfigureAddress(); err != nil {
173 if n.peer != nil && n.peer.name != "" {
174 if err := n.Peer().ConfigureUpState(); err != nil {
178 if err := n.Peer().ConfigureNetworkNamespace(); err != nil {
182 if err := n.Peer().ConfigureAddress(); err != nil {
190 func (n *NetInterface) Unconfigure() {
194 func (n *NetInterface) Name() string {
198 func (n *NetInterface) Type() string {
202 func (n *NetInterface) SetAddress(address string) {
203 n.ip4Address = address
206 func (n *NetInterface) SetIndex(index InterfaceIndex) {
210 func (n *NetInterface) Index() InterfaceIndex {
214 func (n *NetInterface) AddressWithPrefix() AddressWithPrefix {
215 address, _ := ip_types.ParseAddressWithPrefix(n.ip4Address)
219 func (n *NetInterface) IP4AddressWithPrefix() IP4AddressWithPrefix {
220 ip4Prefix, _ := ip_types.ParseIP4Prefix(n.ip4Address)
221 ip4AddressWithPrefix := ip_types.IP4AddressWithPrefix(ip4Prefix)
222 return ip4AddressWithPrefix
225 func (n *NetInterface) IP4AddressString() string {
226 return strings.Split(n.ip4Address, "/")[0]
229 func (n *NetInterface) HwAddress() MacAddress {
233 func (n *NetInterface) Peer() *NetInterface {
237 func (b *NetConfigBase) Name() string {
241 func (b *NetConfigBase) Type() string {
245 func NewNetNamespace(cfg NetDevConfig) (NetworkNamespace, error) {
246 var networkNamespace NetworkNamespace
247 networkNamespace.name = cfg["name"].(string)
248 networkNamespace.category = NetNs
249 return networkNamespace, nil
252 func (ns *NetworkNamespace) Configure() error {
253 return addDelNetns(ns.name, true)
256 func (ns *NetworkNamespace) Unconfigure() {
257 addDelNetns(ns.name, false)
260 func NewBridge(cfg NetDevConfig) (NetworkBridge, error) {
261 var bridge NetworkBridge
262 bridge.name = cfg["name"].(string)
263 bridge.category = Bridge
264 for _, v := range cfg["interfaces"].([]interface{}) {
265 bridge.interfaces = append(bridge.interfaces, v.(string))
268 bridge.networkNamespace = ""
269 if netns, ok := cfg["netns"]; ok {
270 bridge.networkNamespace = netns.(string)
275 func (b *NetworkBridge) Configure() error {
276 return AddBridge(b.name, b.interfaces, b.networkNamespace)
279 func (b *NetworkBridge) Unconfigure() {
280 DelBridge(b.name, b.networkNamespace)
283 func DelBridge(brName, ns string) error {
284 err := SetDevDown(brName, ns)
289 err = addDelBridge(brName, ns, false)
297 func SetDevUp(dev, ns string) error {
298 return setDevUpDown(dev, ns, true)
301 func SetDevDown(dev, ns string) error {
302 return setDevUpDown(dev, ns, false)
305 func DelLink(ifName string) {
306 cmd := exec.Command("ip", "link", "del", ifName)
310 func setDevUpDown(dev, ns string, isUp bool) error {
317 c := []string{"ip", "link", "set", "dev", dev, op}
318 cmd := appendNetns(c, ns)
321 s := fmt.Sprintf("error bringing %s device %s!", dev, op)
327 func addDelNetns(name string, isAdd bool) error {
334 cmd := exec.Command("ip", "netns", op, name)
335 _, err := cmd.CombinedOutput()
337 return errors.New("add/del netns failed")
342 func AddNetns(nsName string) error {
343 return addDelNetns(nsName, true)
346 func DelNetns(nsName string) error {
347 return addDelNetns(nsName, false)
350 func LinkSetNetns(ifName, ns string) error {
351 cmd := exec.Command("ip", "link", "set", "dev", ifName, "up", "netns", ns)
354 return fmt.Errorf("error setting device '%s' to netns '%s: %v", ifName, ns, err)
359 func NewCommand(s []string, ns string) *exec.Cmd {
360 return appendNetns(s, ns)
363 func appendNetns(s []string, ns string) *exec.Cmd {
366 // use default namespace
367 cmd = exec.Command(s[0], s[1:]...)
369 var args = []string{"netns", "exec", ns}
370 args = append(args, s[:]...)
371 cmd = exec.Command("ip", args...)
376 func addDelBridge(brName, ns string, isAdd bool) error {
383 var c = []string{"brctl", op, brName}
384 cmd := appendNetns(c, ns)
387 s := fmt.Sprintf("%s %s failed!", op, brName)
393 func AddBridge(brName string, ifs []string, ns string) error {
394 err := addDelBridge(brName, ns, true)
399 for _, v := range ifs {
400 c := []string{"brctl", "addif", brName, v}
401 cmd := appendNetns(c, ns)
404 s := fmt.Sprintf("error adding %s to bridge %s: %v", v, brName, err)
408 err = SetDevUp(brName, ns)