284 lines
8 KiB
Go
284 lines
8 KiB
Go
//go:build linux
|
|
|
|
package utils
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"errors"
|
|
"golang.org/x/sys/unix"
|
|
"net"
|
|
"os"
|
|
"syscall"
|
|
"unsafe"
|
|
)
|
|
|
|
// InterfaceAddrs returns a list of unicast interface addresses for a specific
|
|
// interface.
|
|
func InterfaceAddrs(ifi *net.Interface) ([]*ExtendedIPNet, error) {
|
|
if ifi == nil {
|
|
return nil, &net.OpError{Op: "route", Net: "ip+net", Source: nil, Addr: nil, Err: errors.New("invalid network interface")}
|
|
}
|
|
ifat, err := interfaceAddrTable(ifi)
|
|
if err != nil {
|
|
err = &net.OpError{Op: "route", Net: "ip+net", Source: nil, Addr: nil, Err: err}
|
|
}
|
|
return ifat, err
|
|
}
|
|
|
|
// If the ifi is nil, interfaceAddrTable returns addresses for all
|
|
// network interfaces. Otherwise it returns addresses for a specific
|
|
// interface.
|
|
//
|
|
// Modified from https://github.com/golang/go/blob/a2d2e6e7cb12c57cd8f5af64909882bab1dbca19/src/net/interface_linux.go
|
|
// Adds support for ExtendedIPNet, no other changes
|
|
func interfaceAddrTable(ifi *net.Interface) ([]*ExtendedIPNet, error) {
|
|
tab, err := syscall.NetlinkRIB(syscall.RTM_GETADDR, syscall.AF_UNSPEC)
|
|
if err != nil {
|
|
return nil, os.NewSyscallError("netlinkrib", err)
|
|
}
|
|
msgs, err := syscall.ParseNetlinkMessage(tab)
|
|
if err != nil {
|
|
return nil, os.NewSyscallError("parsenetlinkmessage", err)
|
|
}
|
|
var ift []net.Interface
|
|
if ifi == nil {
|
|
var err error
|
|
ift, err = interfaceTable(0)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
ifat, err := addrTable(ift, ifi, msgs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return ifat, nil
|
|
}
|
|
|
|
// If the ifindex is zero, interfaceTable returns mappings of all
|
|
// network interfaces. Otherwise it returns a mapping of a specific
|
|
// interface.
|
|
//
|
|
// Modified from https://github.com/golang/go/blob/a2d2e6e7cb12c57cd8f5af64909882bab1dbca19/src/net/interface_linux.go
|
|
// Adds support for ExtendedIPNet, no other changes
|
|
func interfaceTable(ifindex int) ([]net.Interface, error) {
|
|
tab, err := syscall.NetlinkRIB(syscall.RTM_GETLINK, syscall.AF_UNSPEC)
|
|
if err != nil {
|
|
return nil, os.NewSyscallError("netlinkrib", err)
|
|
}
|
|
msgs, err := syscall.ParseNetlinkMessage(tab)
|
|
if err != nil {
|
|
return nil, os.NewSyscallError("parsenetlinkmessage", err)
|
|
}
|
|
var ift []net.Interface
|
|
loop:
|
|
for _, m := range msgs {
|
|
switch m.Header.Type {
|
|
case syscall.NLMSG_DONE:
|
|
break loop
|
|
case syscall.RTM_NEWLINK:
|
|
ifim := (*syscall.IfInfomsg)(unsafe.Pointer(&m.Data[0]))
|
|
if ifindex == 0 || ifindex == int(ifim.Index) {
|
|
attrs, err := syscall.ParseNetlinkRouteAttr(&m)
|
|
if err != nil {
|
|
return nil, os.NewSyscallError("parsenetlinkrouteattr", err)
|
|
}
|
|
ift = append(ift, *newLink(ifim, attrs))
|
|
if ifindex == int(ifim.Index) {
|
|
break loop
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ift, nil
|
|
}
|
|
|
|
// Copied from https://github.com/golang/go/blob/a2d2e6e7cb12c57cd8f5af64909882bab1dbca19/src/net/interface.go
|
|
func interfaceByIndex(ift []net.Interface, index int) (*net.Interface, error) {
|
|
for _, ifi := range ift {
|
|
if index == ifi.Index {
|
|
return &ifi, nil
|
|
}
|
|
}
|
|
return nil, errors.New("no such network interface")
|
|
}
|
|
|
|
// Modified from https://github.com/golang/go/blob/a2d2e6e7cb12c57cd8f5af64909882bab1dbca19/src/net/interface.go
|
|
// Adds support for ExtendedIPNet, no other changes
|
|
func addrTable(ift []net.Interface, ifi *net.Interface, msgs []syscall.NetlinkMessage) ([]*ExtendedIPNet, error) {
|
|
var ifat []*ExtendedIPNet
|
|
loop:
|
|
for _, m := range msgs {
|
|
switch m.Header.Type {
|
|
case syscall.NLMSG_DONE:
|
|
break loop
|
|
case syscall.RTM_NEWADDR:
|
|
ifam := (*syscall.IfAddrmsg)(unsafe.Pointer(&m.Data[0]))
|
|
if len(ift) != 0 || ifi.Index == int(ifam.Index) {
|
|
if len(ift) != 0 {
|
|
var err error
|
|
ifi, err = interfaceByIndex(ift, int(ifam.Index))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
attrs, err := syscall.ParseNetlinkRouteAttr(&m)
|
|
if err != nil {
|
|
return nil, os.NewSyscallError("parsenetlinkrouteattr", err)
|
|
}
|
|
ifa := newAddr(ifam, attrs)
|
|
if ifa != nil {
|
|
ifat = append(ifat, ifa)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ifat, nil
|
|
}
|
|
|
|
// linux/if_addr.h
|
|
|
|
const IFA_FLAGS = 0x8
|
|
|
|
const (
|
|
IFA_F_SECONDARY = 0x01
|
|
IFA_F_TEMPORARY = IFA_F_SECONDARY
|
|
|
|
IFA_F_NODAD = 0x02
|
|
IFA_F_OPTIMISTIC = 0x04
|
|
IFA_F_DADFAILED = 0x08
|
|
IFA_F_HOMEADDRESS = 0x10
|
|
IFA_F_DEPRECATED = 0x20
|
|
IFA_F_TENTATIVE = 0x40
|
|
IFA_F_PERMANENT = 0x80
|
|
IFA_F_MANAGETEMPADDR = 0x100
|
|
IFA_F_NOPREFIXROUTE = 0x200
|
|
IFA_F_MCAUTOJOIN = 0x400
|
|
)
|
|
|
|
// newAddr altered version
|
|
//
|
|
// Modified from https://github.com/golang/go/blob/a2d2e6e7cb12c57cd8f5af64909882bab1dbca19/src/net/interface_linux.go
|
|
// Adds support for ExtendedIPNet, interface address flags
|
|
func newAddr(ifam *syscall.IfAddrmsg, attrs []syscall.NetlinkRouteAttr) *ExtendedIPNet {
|
|
var ipPointToPoint bool
|
|
// Seems like we need to make sure whether the IP interface
|
|
// stack consists of IP point-to-point numbered or unnumbered
|
|
// addressing.
|
|
var flags ExtendedIPFlags
|
|
for _, a := range attrs {
|
|
if a.Attr.Type == syscall.IFA_LOCAL {
|
|
ipPointToPoint = true
|
|
break
|
|
} else if a.Attr.Type == IFA_FLAGS && len(a.Value) == 4 {
|
|
f := binary.LittleEndian.Uint32(a.Value)
|
|
if (f & IFA_F_TEMPORARY) > 0 {
|
|
flags |= FlagTemporary
|
|
}
|
|
if (f & IFA_F_PERMANENT) > 0 {
|
|
flags |= FlagPermanent
|
|
}
|
|
if (f & IFA_F_MANAGETEMPADDR) > 0 {
|
|
flags |= FlagManageTempAddress
|
|
}
|
|
if (f & IFA_F_NOPREFIXROUTE) > 0 {
|
|
flags |= FlagNoPrefixRoute
|
|
}
|
|
if (f & unix.IFA_F_STABLE_PRIVACY) > 0 {
|
|
flags |= FlagStablePrivacy
|
|
}
|
|
if (f & unix.IFA_F_DEPRECATED) > 0 {
|
|
flags |= FlagDeprecated
|
|
}
|
|
}
|
|
}
|
|
for _, a := range attrs {
|
|
if ipPointToPoint && a.Attr.Type == syscall.IFA_ADDRESS {
|
|
continue
|
|
}
|
|
switch ifam.Family {
|
|
case syscall.AF_INET:
|
|
return &ExtendedIPNet{IP: net.IPv4(a.Value[0], a.Value[1], a.Value[2], a.Value[3]), Mask: net.CIDRMask(int(ifam.Prefixlen), 8*net.IPv4len), Flags: flags}
|
|
case syscall.AF_INET6:
|
|
ifa := &ExtendedIPNet{IP: make(net.IP, net.IPv6len), Mask: net.CIDRMask(int(ifam.Prefixlen), 8*net.IPv6len), Flags: flags}
|
|
copy(ifa.IP, a.Value[:])
|
|
return ifa
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
// See linux/if_arp.h.
|
|
// Note that Linux doesn't support IPv4 over IPv6 tunneling.
|
|
sysARPHardwareIPv4IPv4 = 768 // IPv4 over IPv4 tunneling
|
|
sysARPHardwareIPv6IPv6 = 769 // IPv6 over IPv6 tunneling
|
|
sysARPHardwareIPv6IPv4 = 776 // IPv6 over IPv4 tunneling
|
|
sysARPHardwareGREIPv4 = 778 // any over GRE over IPv4 tunneling
|
|
sysARPHardwareGREIPv6 = 823 // any over GRE over IPv6 tunneling
|
|
)
|
|
|
|
// Copied from https://github.com/golang/go/blob/a2d2e6e7cb12c57cd8f5af64909882bab1dbca19/src/net/interface.go
|
|
func linkFlags(rawFlags uint32) net.Flags {
|
|
var f net.Flags
|
|
if rawFlags&syscall.IFF_UP != 0 {
|
|
f |= net.FlagUp
|
|
}
|
|
if rawFlags&syscall.IFF_RUNNING != 0 {
|
|
f |= net.FlagRunning
|
|
}
|
|
if rawFlags&syscall.IFF_BROADCAST != 0 {
|
|
f |= net.FlagBroadcast
|
|
}
|
|
if rawFlags&syscall.IFF_LOOPBACK != 0 {
|
|
f |= net.FlagLoopback
|
|
}
|
|
if rawFlags&syscall.IFF_POINTOPOINT != 0 {
|
|
f |= net.FlagPointToPoint
|
|
}
|
|
if rawFlags&syscall.IFF_MULTICAST != 0 {
|
|
f |= net.FlagMulticast
|
|
}
|
|
return f
|
|
}
|
|
|
|
// Copied from https://github.com/golang/go/blob/a2d2e6e7cb12c57cd8f5af64909882bab1dbca19/src/net/interface.go
|
|
func newLink(ifim *syscall.IfInfomsg, attrs []syscall.NetlinkRouteAttr) *net.Interface {
|
|
ifi := &net.Interface{Index: int(ifim.Index), Flags: linkFlags(ifim.Flags)}
|
|
for _, a := range attrs {
|
|
switch a.Attr.Type {
|
|
case syscall.IFLA_ADDRESS:
|
|
// We never return any /32 or /128 IP address
|
|
// prefix on any IP tunnel interface as the
|
|
// hardware address.
|
|
switch len(a.Value) {
|
|
case net.IPv4len:
|
|
switch ifim.Type {
|
|
case sysARPHardwareIPv4IPv4, sysARPHardwareGREIPv4, sysARPHardwareIPv6IPv4:
|
|
continue
|
|
}
|
|
case net.IPv6len:
|
|
switch ifim.Type {
|
|
case sysARPHardwareIPv6IPv6, sysARPHardwareGREIPv6:
|
|
continue
|
|
}
|
|
}
|
|
var nonzero bool
|
|
for _, b := range a.Value {
|
|
if b != 0 {
|
|
nonzero = true
|
|
break
|
|
}
|
|
}
|
|
if nonzero {
|
|
ifi.HardwareAddr = a.Value[:]
|
|
}
|
|
case syscall.IFLA_IFNAME:
|
|
ifi.Name = string(a.Value[:len(a.Value)-1])
|
|
case syscall.IFLA_MTU:
|
|
ifi.MTU = int(*(*uint32)(unsafe.Pointer(&a.Value[:4][0])))
|
|
}
|
|
}
|
|
return ifi
|
|
}
|