package netlink

import (

"bytes"

"encoding/binary"

"errors"

"fmt"

"io/ioutil"

"net"

"os"

"strconv"

"strings"

"syscall"

"unsafe"

"github.com/vishvananda/netlink/nl"

"github.com/vishvananda/netns"

"golang.org/x/sys/unix"

)

const (

SizeofLinkStats32 = 0x5c

SizeofLinkStats64 = 0xb8

)

const (

TUNTAP_MODE_TUN TuntapMode = unix.IFF_TUN

TUNTAP_MODE_TAP TuntapMode = unix.IFF_TAP

TUNTAP_DEFAULTS TuntapFlag = unix.IFF_TUN_EXCL | unix.IFF_ONE_QUEUE

TUNTAP_VNET_HDR TuntapFlag = unix.IFF_VNET_HDR

TUNTAP_TUN_EXCL TuntapFlag = unix.IFF_TUN_EXCL

TUNTAP_NO_PI TuntapFlag = unix.IFF_NO_PI

TUNTAP_ONE_QUEUE TuntapFlag = unix.IFF_ONE_QUEUE

TUNTAP_MULTI_QUEUE TuntapFlag = unix.IFF_MULTI_QUEUE

TUNTAP_MULTI_QUEUE_DEFAULTS TuntapFlag = TUNTAP_MULTI_QUEUE | TUNTAP_NO_PI

)

var StringToTuntapModeMap = map[string]TuntapMode{

"tun": TUNTAP_MODE_TUN,

"tap": TUNTAP_MODE_TAP,

}

func (ttm TuntapMode) String() string {

switch ttm {

case TUNTAP_MODE_TUN:

return "tun"

case TUNTAP_MODE_TAP:

return "tap"

}

return "unknown"

}

const (

VF_LINK_STATE_AUTO uint32 = 0

VF_LINK_STATE_ENABLE uint32 = 1

VF_LINK_STATE_DISABLE uint32 = 2

)

var macvlanModes = [...]uint32{

0,

nl.MACVLAN_MODE_PRIVATE,

nl.MACVLAN_MODE_VEPA,

nl.MACVLAN_MODE_BRIDGE,

nl.MACVLAN_MODE_PASSTHRU,

nl.MACVLAN_MODE_SOURCE,

}

func ensureIndex(link *LinkAttrs) {

if link != nil && link.Index == 0 {

newlink, _ := LinkByName(link.Name)

if newlink != nil {

link.Index = newlink.Attrs().Index

}

}

}

func (h *Handle) ensureIndex(link *LinkAttrs) {

if link != nil && link.Index == 0 {

newlink, _ := h.LinkByName(link.Name)

if newlink != nil {

link.Index = newlink.Attrs().Index

}

}

}

func (h *Handle) LinkSetARPOff(link Link) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Change |= unix.IFF_NOARP

msg.Flags |= unix.IFF_NOARP

msg.Index = int32(base.Index)

req.AddData(msg)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

func LinkSetARPOff(link Link) error {

return pkgHandle.LinkSetARPOff(link)

}

func (h *Handle) LinkSetARPOn(link Link) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Change |= unix.IFF_NOARP

msg.Flags &= ^uint32(unix.IFF_NOARP)

msg.Index = int32(base.Index)

req.AddData(msg)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

func LinkSetARPOn(link Link) error {

return pkgHandle.LinkSetARPOn(link)

}

func (h *Handle) SetPromiscOn(link Link) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Change = unix.IFF_PROMISC

msg.Flags = unix.IFF_PROMISC

msg.Index = int32(base.Index)

req.AddData(msg)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetAllmulticastOn enables the reception of all hardware multicast packets for the link device.

// Equivalent to: `ip link set $link allmulticast on`

func LinkSetAllmulticastOn(link Link) error {

return pkgHandle.LinkSetAllmulticastOn(link)

}

// LinkSetAllmulticastOn enables the reception of all hardware multicast packets for the link device.

// Equivalent to: `ip link set $link allmulticast on`

func (h *Handle) LinkSetAllmulticastOn(link Link) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_NEWLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Change = unix.IFF_ALLMULTI

msg.Flags = unix.IFF_ALLMULTI

msg.Index = int32(base.Index)

req.AddData(msg)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetAllmulticastOff disables the reception of all hardware multicast packets for the link device.

// Equivalent to: `ip link set $link allmulticast off`

func LinkSetAllmulticastOff(link Link) error {

return pkgHandle.LinkSetAllmulticastOff(link)

}

// LinkSetAllmulticastOff disables the reception of all hardware multicast packets for the link device.

// Equivalent to: `ip link set $link allmulticast off`

func (h *Handle) LinkSetAllmulticastOff(link Link) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_NEWLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Change = unix.IFF_ALLMULTI

msg.Index = int32(base.Index)

req.AddData(msg)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetMulticastOn enables the reception of multicast packets for the link device.

// Equivalent to: `ip link set $link multicast on`

func LinkSetMulticastOn(link Link) error {

return pkgHandle.LinkSetMulticastOn(link)

}

// LinkSetMulticastOn enables the reception of multicast packets for the link device.

// Equivalent to: `ip link set $link multicast on`

func (h *Handle) LinkSetMulticastOn(link Link) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_NEWLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Change = unix.IFF_MULTICAST

msg.Flags = unix.IFF_MULTICAST

msg.Index = int32(base.Index)

req.AddData(msg)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetAllmulticastOff disables the reception of multicast packets for the link device.

// Equivalent to: `ip link set $link multicast off`

func LinkSetMulticastOff(link Link) error {

return pkgHandle.LinkSetMulticastOff(link)

}

// LinkSetAllmulticastOff disables the reception of multicast packets for the link device.

// Equivalent to: `ip link set $link multicast off`

func (h *Handle) LinkSetMulticastOff(link Link) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_NEWLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Change = unix.IFF_MULTICAST

msg.Index = int32(base.Index)

req.AddData(msg)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

func MacvlanMACAddrAdd(link Link, addr net.HardwareAddr) error {

return pkgHandle.MacvlanMACAddrAdd(link, addr)

}

func (h *Handle) MacvlanMACAddrAdd(link Link, addr net.HardwareAddr) error {

return h.macvlanMACAddrChange(link, []net.HardwareAddr{addr}, nl.MACVLAN_MACADDR_ADD)

}

func MacvlanMACAddrDel(link Link, addr net.HardwareAddr) error {

return pkgHandle.MacvlanMACAddrDel(link, addr)

}

func (h *Handle) MacvlanMACAddrDel(link Link, addr net.HardwareAddr) error {

return h.macvlanMACAddrChange(link, []net.HardwareAddr{addr}, nl.MACVLAN_MACADDR_DEL)

}

func MacvlanMACAddrFlush(link Link) error {

return pkgHandle.MacvlanMACAddrFlush(link)

}

func (h *Handle) MacvlanMACAddrFlush(link Link) error {

return h.macvlanMACAddrChange(link, nil, nl.MACVLAN_MACADDR_FLUSH)

}

func MacvlanMACAddrSet(link Link, addrs []net.HardwareAddr) error {

return pkgHandle.MacvlanMACAddrSet(link, addrs)

}

func (h *Handle) MacvlanMACAddrSet(link Link, addrs []net.HardwareAddr) error {

return h.macvlanMACAddrChange(link, addrs, nl.MACVLAN_MACADDR_SET)

}

func (h *Handle) macvlanMACAddrChange(link Link, addrs []net.HardwareAddr, mode uint32) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_NEWLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

linkInfo := nl.NewRtAttr(unix.IFLA_LINKINFO, nil)

linkInfo.AddRtAttr(nl.IFLA_INFO_KIND, nl.NonZeroTerminated(link.Type()))

inner := linkInfo.AddRtAttr(nl.IFLA_INFO_DATA, nil)

// IFLA_MACVLAN_MACADDR_MODE = mode

b := make([]byte, 4)

native.PutUint32(b, mode)

inner.AddRtAttr(nl.IFLA_MACVLAN_MACADDR_MODE, b)

// populate message with MAC addrs, if necessary

switch mode {

case nl.MACVLAN_MACADDR_ADD, nl.MACVLAN_MACADDR_DEL:

if len(addrs) == 1 {

inner.AddRtAttr(nl.IFLA_MACVLAN_MACADDR, []byte(addrs[0]))

}

case nl.MACVLAN_MACADDR_SET:

mad := inner.AddRtAttr(nl.IFLA_MACVLAN_MACADDR_DATA, nil)

for _, addr := range addrs {

mad.AddRtAttr(nl.IFLA_MACVLAN_MACADDR, []byte(addr))

}

}

req.AddData(linkInfo)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetMacvlanMode sets the mode of a macvlan or macvtap link device.

// Note that passthrough mode cannot be set to and from and will fail.

// Equivalent to: `ip link set $link type (macvlan|macvtap) mode $mode

func LinkSetMacvlanMode(link Link, mode MacvlanMode) error {

return pkgHandle.LinkSetMacvlanMode(link, mode)

}

// LinkSetMacvlanMode sets the mode of the macvlan or macvtap link device.

// Note that passthrough mode cannot be set to and from and will fail.

// Equivalent to: `ip link set $link type (macvlan|macvtap) mode $mode

func (h *Handle) LinkSetMacvlanMode(link Link, mode MacvlanMode) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_NEWLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

linkInfo := nl.NewRtAttr(unix.IFLA_LINKINFO, nil)

linkInfo.AddRtAttr(nl.IFLA_INFO_KIND, nl.NonZeroTerminated(link.Type()))

data := linkInfo.AddRtAttr(nl.IFLA_INFO_DATA, nil)

data.AddRtAttr(nl.IFLA_MACVLAN_MODE, nl.Uint32Attr(macvlanModes[mode]))

req.AddData(linkInfo)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

func BridgeSetMcastSnoop(link Link, on bool) error {

return pkgHandle.BridgeSetMcastSnoop(link, on)

}

func (h *Handle) BridgeSetMcastSnoop(link Link, on bool) error {

bridge := link.(*Bridge)

bridge.MulticastSnooping = &on

return h.linkModify(bridge, unix.NLM_F_ACK)

}

func BridgeSetVlanFiltering(link Link, on bool) error {

return pkgHandle.BridgeSetVlanFiltering(link, on)

}

func (h *Handle) BridgeSetVlanFiltering(link Link, on bool) error {

bridge := link.(*Bridge)

bridge.VlanFiltering = &on

return h.linkModify(bridge, unix.NLM_F_ACK)

}

func BridgeSetVlanDefaultPVID(link Link, pvid uint16) error {

return pkgHandle.BridgeSetVlanDefaultPVID(link, pvid)

}

func (h *Handle) BridgeSetVlanDefaultPVID(link Link, pvid uint16) error {

bridge := link.(*Bridge)

bridge.VlanDefaultPVID = &pvid

return h.linkModify(bridge, unix.NLM_F_ACK)

}

func SetPromiscOn(link Link) error {

return pkgHandle.SetPromiscOn(link)

}

func (h *Handle) SetPromiscOff(link Link) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Change = unix.IFF_PROMISC

msg.Index = int32(base.Index)

req.AddData(msg)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

func SetPromiscOff(link Link) error {

return pkgHandle.SetPromiscOff(link)

}

// LinkSetUp enables the link device.

// Equivalent to: `ip link set $link up`

func LinkSetUp(link Link) error {

return pkgHandle.LinkSetUp(link)

}

// LinkSetUp enables the link device.

// Equivalent to: `ip link set $link up`

func (h *Handle) LinkSetUp(link Link) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_NEWLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Change = unix.IFF_UP

msg.Flags = unix.IFF_UP

msg.Index = int32(base.Index)

req.AddData(msg)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetDown disables link device.

// Equivalent to: `ip link set $link down`

func LinkSetDown(link Link) error {

return pkgHandle.LinkSetDown(link)

}

// LinkSetDown disables link device.

// Equivalent to: `ip link set $link down`

func (h *Handle) LinkSetDown(link Link) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_NEWLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Change = unix.IFF_UP

msg.Index = int32(base.Index)

req.AddData(msg)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetMTU sets the mtu of the link device.

// Equivalent to: `ip link set $link mtu $mtu`

func LinkSetMTU(link Link, mtu int) error {

return pkgHandle.LinkSetMTU(link, mtu)

}

// LinkSetMTU sets the mtu of the link device.

// Equivalent to: `ip link set $link mtu $mtu`

func (h *Handle) LinkSetMTU(link Link, mtu int) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

b := make([]byte, 4)

native.PutUint32(b, uint32(mtu))

data := nl.NewRtAttr(unix.IFLA_MTU, b)

req.AddData(data)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetName sets the name of the link device.

// Equivalent to: `ip link set $link name $name`

func LinkSetName(link Link, name string) error {

return pkgHandle.LinkSetName(link, name)

}

// LinkSetName sets the name of the link device.

// Equivalent to: `ip link set $link name $name`

func (h *Handle) LinkSetName(link Link, name string) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

data := nl.NewRtAttr(unix.IFLA_IFNAME, []byte(name))

req.AddData(data)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetAlias sets the alias of the link device.

// Equivalent to: `ip link set dev $link alias $name`

func LinkSetAlias(link Link, name string) error {

return pkgHandle.LinkSetAlias(link, name)

}

// LinkSetAlias sets the alias of the link device.

// Equivalent to: `ip link set dev $link alias $name`

func (h *Handle) LinkSetAlias(link Link, name string) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

data := nl.NewRtAttr(unix.IFLA_IFALIAS, []byte(name))

req.AddData(data)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkAddAltName adds a new alternative name for the link device.

// Equivalent to: `ip link property add $link altname $name`

func LinkAddAltName(link Link, name string) error {

return pkgHandle.LinkAddAltName(link, name)

}

// LinkAddAltName adds a new alternative name for the link device.

// Equivalent to: `ip link property add $link altname $name`

func (h *Handle) LinkAddAltName(link Link, name string) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_NEWLINKPROP, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

data := nl.NewRtAttr(unix.IFLA_PROP_LIST|unix.NLA_F_NESTED, nil)

data.AddRtAttr(unix.IFLA_ALT_IFNAME, []byte(name))

req.AddData(data)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkDelAltName delete an alternative name for the link device.

// Equivalent to: `ip link property del $link altname $name`

func LinkDelAltName(link Link, name string) error {

return pkgHandle.LinkDelAltName(link, name)

}

// LinkDelAltName delete an alternative name for the link device.

// Equivalent to: `ip link property del $link altname $name`

func (h *Handle) LinkDelAltName(link Link, name string) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_DELLINKPROP, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

data := nl.NewRtAttr(unix.IFLA_PROP_LIST|unix.NLA_F_NESTED, nil)

data.AddRtAttr(unix.IFLA_ALT_IFNAME, []byte(name))

req.AddData(data)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetHardwareAddr sets the hardware address of the link device.

// Equivalent to: `ip link set $link address $hwaddr`

func LinkSetHardwareAddr(link Link, hwaddr net.HardwareAddr) error {

return pkgHandle.LinkSetHardwareAddr(link, hwaddr)

}

// LinkSetHardwareAddr sets the hardware address of the link device.

// Equivalent to: `ip link set $link address $hwaddr`

func (h *Handle) LinkSetHardwareAddr(link Link, hwaddr net.HardwareAddr) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

data := nl.NewRtAttr(unix.IFLA_ADDRESS, []byte(hwaddr))

req.AddData(data)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetVfHardwareAddr sets the hardware address of a vf for the link.

// Equivalent to: `ip link set $link vf $vf mac $hwaddr`

func LinkSetVfHardwareAddr(link Link, vf int, hwaddr net.HardwareAddr) error {

return pkgHandle.LinkSetVfHardwareAddr(link, vf, hwaddr)

}

// LinkSetVfHardwareAddr sets the hardware address of a vf for the link.

// Equivalent to: `ip link set $link vf $vf mac $hwaddr`

func (h *Handle) LinkSetVfHardwareAddr(link Link, vf int, hwaddr net.HardwareAddr) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

data := nl.NewRtAttr(unix.IFLA_VFINFO_LIST, nil)

info := data.AddRtAttr(nl.IFLA_VF_INFO, nil)

vfmsg := nl.VfMac{

Vf: uint32(vf),

}

copy(vfmsg.Mac[:], []byte(hwaddr))

info.AddRtAttr(nl.IFLA_VF_MAC, vfmsg.Serialize())

req.AddData(data)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetVfVlan sets the vlan of a vf for the link.

// Equivalent to: `ip link set $link vf $vf vlan $vlan`

func LinkSetVfVlan(link Link, vf, vlan int) error {

return pkgHandle.LinkSetVfVlan(link, vf, vlan)

}

// LinkSetVfVlan sets the vlan of a vf for the link.

// Equivalent to: `ip link set $link vf $vf vlan $vlan`

func (h *Handle) LinkSetVfVlan(link Link, vf, vlan int) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

data := nl.NewRtAttr(unix.IFLA_VFINFO_LIST, nil)

info := data.AddRtAttr(nl.IFLA_VF_INFO, nil)

vfmsg := nl.VfVlan{

Vf: uint32(vf),

Vlan: uint32(vlan),

}

info.AddRtAttr(nl.IFLA_VF_VLAN, vfmsg.Serialize())

req.AddData(data)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetVfVlanQos sets the vlan and qos priority of a vf for the link.

// Equivalent to: `ip link set $link vf $vf vlan $vlan qos $qos`

func LinkSetVfVlanQos(link Link, vf, vlan, qos int) error {

return pkgHandle.LinkSetVfVlanQos(link, vf, vlan, qos)

}

// LinkSetVfVlanQos sets the vlan and qos priority of a vf for the link.

// Equivalent to: `ip link set $link vf $vf vlan $vlan qos $qos`

func (h *Handle) LinkSetVfVlanQos(link Link, vf, vlan, qos int) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

data := nl.NewRtAttr(unix.IFLA_VFINFO_LIST, nil)

info := data.AddRtAttr(nl.IFLA_VF_INFO, nil)

vfmsg := nl.VfVlan{

Vf: uint32(vf),

Vlan: uint32(vlan),

Qos: uint32(qos),

}

info.AddRtAttr(nl.IFLA_VF_VLAN, vfmsg.Serialize())

req.AddData(data)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetVfVlanQosProto sets the vlan, qos and protocol of a vf for the link.

// Equivalent to: `ip link set $link vf $vf vlan $vlan qos $qos proto $proto`

func LinkSetVfVlanQosProto(link Link, vf, vlan, qos, proto int) error {

return pkgHandle.LinkSetVfVlanQosProto(link, vf, vlan, qos, proto)

}

// LinkSetVfVlanQosProto sets the vlan, qos and protocol of a vf for the link.

// Equivalent to: `ip link set $link vf $vf vlan $vlan qos $qos proto $proto`

func (h *Handle) LinkSetVfVlanQosProto(link Link, vf, vlan, qos, proto int) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

data := nl.NewRtAttr(unix.IFLA_VFINFO_LIST, nil)

vfInfo := data.AddRtAttr(nl.IFLA_VF_INFO, nil)

vfVlanList := vfInfo.AddRtAttr(nl.IFLA_VF_VLAN_LIST, nil)

vfmsg := nl.VfVlanInfo{

VfVlan: nl.VfVlan{

Vf: uint32(vf),

Vlan: uint32(vlan),

Qos: uint32(qos),

},

VlanProto: (uint16(proto)>>8)&0xFF | (uint16(proto)&0xFF)<<8,

}

vfVlanList.AddRtAttr(nl.IFLA_VF_VLAN_INFO, vfmsg.Serialize())

req.AddData(data)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetVfTxRate sets the tx rate of a vf for the link.

// Equivalent to: `ip link set $link vf $vf rate $rate`

func LinkSetVfTxRate(link Link, vf, rate int) error {

return pkgHandle.LinkSetVfTxRate(link, vf, rate)

}

// LinkSetVfTxRate sets the tx rate of a vf for the link.

// Equivalent to: `ip link set $link vf $vf rate $rate`

func (h *Handle) LinkSetVfTxRate(link Link, vf, rate int) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

data := nl.NewRtAttr(unix.IFLA_VFINFO_LIST, nil)

info := data.AddRtAttr(nl.IFLA_VF_INFO, nil)

vfmsg := nl.VfTxRate{

Vf: uint32(vf),

Rate: uint32(rate),

}

info.AddRtAttr(nl.IFLA_VF_TX_RATE, vfmsg.Serialize())

req.AddData(data)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetVfRate sets the min and max tx rate of a vf for the link.

// Equivalent to: `ip link set $link vf $vf min_tx_rate $min_rate max_tx_rate $max_rate`

func LinkSetVfRate(link Link, vf, minRate, maxRate int) error {

return pkgHandle.LinkSetVfRate(link, vf, minRate, maxRate)

}

// LinkSetVfRate sets the min and max tx rate of a vf for the link.

// Equivalent to: `ip link set $link vf $vf min_tx_rate $min_rate max_tx_rate $max_rate`

func (h *Handle) LinkSetVfRate(link Link, vf, minRate, maxRate int) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

data := nl.NewRtAttr(unix.IFLA_VFINFO_LIST, nil)

info := data.AddRtAttr(nl.IFLA_VF_INFO, nil)

vfmsg := nl.VfRate{

Vf: uint32(vf),

MinTxRate: uint32(minRate),

MaxTxRate: uint32(maxRate),

}

info.AddRtAttr(nl.IFLA_VF_RATE, vfmsg.Serialize())

req.AddData(data)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetVfState enables/disables virtual link state on a vf.

// Equivalent to: `ip link set $link vf $vf state $state`

func LinkSetVfState(link Link, vf int, state uint32) error {

return pkgHandle.LinkSetVfState(link, vf, state)

}

// LinkSetVfState enables/disables virtual link state on a vf.

// Equivalent to: `ip link set $link vf $vf state $state`

func (h *Handle) LinkSetVfState(link Link, vf int, state uint32) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

data := nl.NewRtAttr(unix.IFLA_VFINFO_LIST, nil)

info := data.AddRtAttr(nl.IFLA_VF_INFO, nil)

vfmsg := nl.VfLinkState{

Vf: uint32(vf),

LinkState: state,

}

info.AddRtAttr(nl.IFLA_VF_LINK_STATE, vfmsg.Serialize())

req.AddData(data)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetVfSpoofchk enables/disables spoof check on a vf for the link.

// Equivalent to: `ip link set $link vf $vf spoofchk $check`

func LinkSetVfSpoofchk(link Link, vf int, check bool) error {

return pkgHandle.LinkSetVfSpoofchk(link, vf, check)

}

// LinkSetVfSpoofchk enables/disables spoof check on a vf for the link.

// Equivalent to: `ip link set $link vf $vf spoofchk $check`

func (h *Handle) LinkSetVfSpoofchk(link Link, vf int, check bool) error {

var setting uint32

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

data := nl.NewRtAttr(unix.IFLA_VFINFO_LIST, nil)

info := data.AddRtAttr(nl.IFLA_VF_INFO, nil)

if check {

setting = 1

}

vfmsg := nl.VfSpoofchk{

Vf: uint32(vf),

Setting: setting,

}

info.AddRtAttr(nl.IFLA_VF_SPOOFCHK, vfmsg.Serialize())

req.AddData(data)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetVfTrust enables/disables trust state on a vf for the link.

// Equivalent to: `ip link set $link vf $vf trust $state`

func LinkSetVfTrust(link Link, vf int, state bool) error {

return pkgHandle.LinkSetVfTrust(link, vf, state)

}

// LinkSetVfTrust enables/disables trust state on a vf for the link.

// Equivalent to: `ip link set $link vf $vf trust $state`

func (h *Handle) LinkSetVfTrust(link Link, vf int, state bool) error {

var setting uint32

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

data := nl.NewRtAttr(unix.IFLA_VFINFO_LIST, nil)

info := data.AddRtAttr(nl.IFLA_VF_INFO, nil)

if state {

setting = 1

}

vfmsg := nl.VfTrust{

Vf: uint32(vf),

Setting: setting,

}

info.AddRtAttr(nl.IFLA_VF_TRUST, vfmsg.Serialize())

req.AddData(data)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetVfNodeGUID sets the node GUID of a vf for the link.

// Equivalent to: `ip link set dev $link vf $vf node_guid $nodeguid`

func LinkSetVfNodeGUID(link Link, vf int, nodeguid net.HardwareAddr) error {

return pkgHandle.LinkSetVfGUID(link, vf, nodeguid, nl.IFLA_VF_IB_NODE_GUID)

}

// LinkSetVfPortGUID sets the port GUID of a vf for the link.

// Equivalent to: `ip link set dev $link vf $vf port_guid $portguid`

func LinkSetVfPortGUID(link Link, vf int, portguid net.HardwareAddr) error {

return pkgHandle.LinkSetVfGUID(link, vf, portguid, nl.IFLA_VF_IB_PORT_GUID)

}

// LinkSetVfGUID sets the node or port GUID of a vf for the link.

func (h *Handle) LinkSetVfGUID(link Link, vf int, vfGuid net.HardwareAddr, guidType int) error {

var err error

var guid uint64

buf := bytes.NewBuffer(vfGuid)

err = binary.Read(buf, binary.BigEndian, &guid)

if err != nil {

return err

}

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

data := nl.NewRtAttr(unix.IFLA_VFINFO_LIST, nil)

info := data.AddRtAttr(nl.IFLA_VF_INFO, nil)

vfmsg := nl.VfGUID{

Vf: uint32(vf),

GUID: guid,

}

info.AddRtAttr(guidType, vfmsg.Serialize())

req.AddData(data)

_, err = req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetMaster sets the master of the link device.

// Equivalent to: `ip link set $link master $master`

func LinkSetMaster(link Link, master Link) error {

return pkgHandle.LinkSetMaster(link, master)

}

// LinkSetMaster sets the master of the link device.

// Equivalent to: `ip link set $link master $master`

func (h *Handle) LinkSetMaster(link Link, master Link) error {

index := 0

if master != nil {

masterBase := master.Attrs()

h.ensureIndex(masterBase)

index = masterBase.Index

}

if index <= 0 {

return fmt.Errorf("Device does not exist")

}

return h.LinkSetMasterByIndex(link, index)

}

// LinkSetNoMaster removes the master of the link device.

// Equivalent to: `ip link set $link nomaster`

func LinkSetNoMaster(link Link) error {

return pkgHandle.LinkSetNoMaster(link)

}

// LinkSetNoMaster removes the master of the link device.

// Equivalent to: `ip link set $link nomaster`

func (h *Handle) LinkSetNoMaster(link Link) error {

return h.LinkSetMasterByIndex(link, 0)

}

// LinkSetMasterByIndex sets the master of the link device.

// Equivalent to: `ip link set $link master $master`

func LinkSetMasterByIndex(link Link, masterIndex int) error {

return pkgHandle.LinkSetMasterByIndex(link, masterIndex)

}

// LinkSetMasterByIndex sets the master of the link device.

// Equivalent to: `ip link set $link master $master`

func (h *Handle) LinkSetMasterByIndex(link Link, masterIndex int) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

b := make([]byte, 4)

native.PutUint32(b, uint32(masterIndex))

data := nl.NewRtAttr(unix.IFLA_MASTER, b)

req.AddData(data)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetNsPid puts the device into a new network namespace. The

// pid must be a pid of a running process.

// Equivalent to: `ip link set $link netns $pid`

func LinkSetNsPid(link Link, nspid int) error {

return pkgHandle.LinkSetNsPid(link, nspid)

}

// LinkSetNsPid puts the device into a new network namespace. The

// pid must be a pid of a running process.

// Equivalent to: `ip link set $link netns $pid`

func (h *Handle) LinkSetNsPid(link Link, nspid int) error {

base := link.Attrs()

h.ensureIndex(base)

req := h.newNetlinkRequest(unix.RTM_SETLINK, unix.NLM_F_ACK)

msg := nl.NewIfInfomsg(unix.AF_UNSPEC)

msg.Index = int32(base.Index)

req.AddData(msg)

b := make([]byte, 4)

native.PutUint32(b, uint32(nspid))

data := nl.NewRtAttr(unix.IFLA_NET_NS_PID, b)

req.AddData(data)

_, err := req.Execute(unix.NETLINK_ROUTE, 0)

return err

}

// LinkSetNsFd puts the device into a new network namespace. The

// fd must be an open file descriptor to a network namespace.

// Similar to: `ip link set $link netns $ns`

func LinkSetNsFd(link Link, fd int) error {