src/net/interface_linux.go

// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package net

import (
	"os"
	"slices"
	"syscall"
	"unsafe"
)

// If the ifindex is zero, interfaceTable returns mappings of all
// network interfaces. Otherwise it returns a mapping of a specific
// interface.
func interfaceTable(ifindex int) ([]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 []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
}

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
)

func newLink(ifim *syscall.IfInfomsg, attrs []syscall.NetlinkRouteAttr) *Interface {
	ifi := &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 IPv4len:
				switch ifim.Type {
				case sysARPHardwareIPv4IPv4, sysARPHardwareGREIPv4, sysARPHardwareIPv6IPv4:
					continue
				}
			case 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
}

func linkFlags(rawFlags uint32) Flags {
	var f Flags
	if rawFlags&syscall.IFF_UP != 0 {
		f |= FlagUp
	}
	if rawFlags&syscall.IFF_RUNNING != 0 {
		f |= FlagRunning
	}
	if rawFlags&syscall.IFF_BROADCAST != 0 {
		f |= FlagBroadcast
	}
	if rawFlags&syscall.IFF_LOOPBACK != 0 {
		f |= FlagLoopback
	}
	if rawFlags&syscall.IFF_POINTOPOINT != 0 {
		f |= FlagPointToPoint
	}
	if rawFlags&syscall.IFF_MULTICAST != 0 {
		f |= FlagMulticast
	}
	return f
}

// If the ifi is nil, interfaceAddrTable returns addresses for all
// network interfaces. Otherwise it returns addresses for a specific
// interface.
func interfaceAddrTable(ifi *Interface) ([]Addr, error) {
	index := 0
	if ifi != nil {
		index = ifi.Index
	}
	msgs, err := netlinkAddrMessages(index)
	if err != nil {
		// The kernel is older than Linux 4.20 or doesn't support
		// filtered dumps for some other reason. Fall back to dumping
		// every address on the host.
		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)
		}
	}
	ifat, err := addrTable(ifi, msgs)
	if err != nil {
		return nil, err
	}
	return ifat, nil
}

const (
	sysSOL_NETLINK            = 270 // see linux/socket.h
	sysNETLINK_GET_STRICT_CHK = 12  // see linux/netlink.h
)

// netlinkAddrMessages returns the RTM_NEWADDR messages for the
// interface with the given index, or for all interfaces if index is
// zero.
//
// Rather than a single AF_UNSPEC dump of every address on the host,
// it makes one dump request each for AF_INET and AF_INET6 with
// NETLINK_GET_STRICT_CHK enabled and the interface index set in the
// request. Since Linux 4.20, the kernel then walks only that
// interface's addresses, so calling Addrs on each of N interfaces is
// O(N) rather than O(N^2) kernel work, which older kernels do while
// holding the global RTNL lock. Since Linux 6.9, per-family address
// dumps don't take the RTNL lock at all, but AF_UNSPEC dumps still do.
func netlinkAddrMessages(index int) ([]syscall.NetlinkMessage, error) {
	s, err := syscall.Socket(syscall.AF_NETLINK, syscall.SOCK_RAW|syscall.SOCK_CLOEXEC, syscall.NETLINK_ROUTE)
	if err != nil {
		return nil, err
	}
	defer syscall.Close(s)
	if err := syscall.SetsockoptInt(s, sysSOL_NETLINK, sysNETLINK_GET_STRICT_CHK, 1); err != nil {
		return nil, err
	}
	sa := &syscall.SockaddrNetlink{Family: syscall.AF_NETLINK}
	if err := syscall.Bind(s, sa); err != nil {
		return nil, err
	}
	lsa, err := syscall.Getsockname(s)
	if err != nil {
		return nil, err
	}
	lsanl, ok := lsa.(*syscall.SockaddrNetlink)
	if !ok {
		return nil, syscall.EINVAL
	}

	var msgs []syscall.NetlinkMessage
	rb := make([]byte, syscall.Getpagesize())
	for i, family := range [...]uint8{syscall.AF_INET, syscall.AF_INET6} {
		seq := uint32(i + 1)
		req := struct {
			hdr  syscall.NlMsghdr
			ifam syscall.IfAddrmsg
		}{
			hdr: syscall.NlMsghdr{
				Type:  syscall.RTM_GETADDR,
				Flags: syscall.NLM_F_DUMP | syscall.NLM_F_REQUEST,
				Seq:   seq,
			},
			ifam: syscall.IfAddrmsg{Family: family, Index: uint32(index)},
		}
		req.hdr.Len = uint32(unsafe.Sizeof(req))
		wb := unsafe.Slice((*byte)(unsafe.Pointer(&req)), unsafe.Sizeof(req))
		if err := syscall.Sendto(s, wb, 0, sa); err != nil {
			return nil, err
		}
	recv:
		for {
			nr, _, err := syscall.Recvfrom(s, rb, 0)
			if err != nil {
				return nil, err
			}
			if nr < syscall.NLMSG_HDRLEN {
				return nil, syscall.EINVAL
			}
			// Copy the batch, as the parsed messages refer to it.
			batch, err := syscall.ParseNetlinkMessage(slices.Clone(rb[:nr]))
			if err != nil {
				return nil, err
			}
			for _, m := range batch {
				if m.Header.Seq != seq || m.Header.Pid != lsanl.Pid {
					return nil, syscall.EINVAL
				}
				switch m.Header.Type {
				case syscall.NLMSG_DONE:
					err := netlinkErrno(&m)
					if err == syscall.ENODEV && index != 0 {
						// The interface went away, so it has
						// no addresses.
						return nil, nil
					}
					if err != nil {
						return nil, err
					}
					break recv
				case syscall.NLMSG_ERROR:
					if err := netlinkErrno(&m); err != nil {
						return nil, err
					}
					return nil, syscall.EINVAL
				case syscall.RTM_NEWADDR:
					if len(m.Data) < syscall.SizeofIfAddrmsg {
						return nil, syscall.EINVAL
					}
					// If the kernel has no handler for the
					// requested family (for example, IPv6 is
					// disabled), it answers with an AF_UNSPEC
					// dump instead, so skip other families.
					ifam := (*syscall.IfAddrmsg)(unsafe.Pointer(&m.Data[0]))
					if ifam.Family == family {
						msgs = append(msgs, m)
					}
				}
			}
		}
	}
	return msgs, nil
}

// netlinkErrno returns the error, if any, carried in the payload of an
// NLMSG_DONE or NLMSG_ERROR message.
func netlinkErrno(m *syscall.NetlinkMessage) error {
	if len(m.Data) < 4 {
		return nil
	}
	if errno := *(*int32)(unsafe.Pointer(&m.Data[0])); errno < 0 {
		return syscall.Errno(-errno)
	}
	return nil
}

func addrTable(ifi *Interface, msgs []syscall.NetlinkMessage) ([]Addr, error) {
	var ifat []Addr
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 ifi == nil || ifi.Index == int(ifam.Index) {
				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
}

func newAddr(ifam *syscall.IfAddrmsg, attrs []syscall.NetlinkRouteAttr) Addr {
	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.
	for _, a := range attrs {
		if a.Attr.Type == syscall.IFA_LOCAL {
			ipPointToPoint = true
			break
		}
	}
	for _, a := range attrs {
		if ipPointToPoint && a.Attr.Type == syscall.IFA_ADDRESS {
			continue
		}
		switch ifam.Family {
		case syscall.AF_INET:
			return &IPNet{IP: IPv4(a.Value[0], a.Value[1], a.Value[2], a.Value[3]), Mask: CIDRMask(int(ifam.Prefixlen), 8*IPv4len)}
		case syscall.AF_INET6:
			ifa := &IPNet{IP: make(IP, IPv6len), Mask: CIDRMask(int(ifam.Prefixlen), 8*IPv6len)}
			copy(ifa.IP, a.Value[:])
			return ifa
		}
	}
	return nil
}

// interfaceMulticastAddrTable returns addresses for a specific
// interface.
func interfaceMulticastAddrTable(ifi *Interface) ([]Addr, error) {
	ifmat4 := parseProcNetIGMP("/proc/net/igmp", ifi)
	ifmat6 := parseProcNetIGMP6("/proc/net/igmp6", ifi)
	return append(ifmat4, ifmat6...), nil
}

func parseProcNetIGMP(path string, ifi *Interface) []Addr {
	fd, err := open(path)
	if err != nil {
		return nil
	}
	defer fd.close()
	var (
		ifmat []Addr
		name  string
	)
	fd.readLine() // skip first line
	b := make([]byte, IPv4len)
	for l, ok := fd.readLine(); ok; l, ok = fd.readLine() {
		f := splitAtBytes(l, " :\r\t\n")
		if len(f) < 4 {
			continue
		}
		switch {
		case l[0] != ' ' && l[0] != '\t': // new interface line
			name = f[1]
		case len(f[0]) == 8:
			if ifi == nil || name == ifi.Name {
				// The Linux kernel puts the IP
				// address in /proc/net/igmp in native
				// endianness.
				for i := 0; i+1 < len(f[0]); i += 2 {
					b[i/2], _ = xtoi2(f[0][i:i+2], 0)
				}
				i := *(*uint32)(unsafe.Pointer(&b[:4][0]))
				ifma := &IPAddr{IP: IPv4(byte(i>>24), byte(i>>16), byte(i>>8), byte(i))}
				ifmat = append(ifmat, ifma)
			}
		}
	}
	return ifmat
}

func parseProcNetIGMP6(path string, ifi *Interface) []Addr {
	fd, err := open(path)
	if err != nil {
		return nil
	}
	defer fd.close()
	var ifmat []Addr
	b := make([]byte, IPv6len)
	for l, ok := fd.readLine(); ok; l, ok = fd.readLine() {
		f := splitAtBytes(l, " \r\t\n")
		if len(f) < 6 {
			continue
		}
		if ifi == nil || f[1] == ifi.Name {
			for i := 0; i+1 < len(f[2]); i += 2 {
				b[i/2], _ = xtoi2(f[2][i:i+2], 0)
			}
			ifma := &IPAddr{IP: IP{b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8], b[9], b[10], b[11], b[12], b[13], b[14], b[15]}}
			ifmat = append(ifmat, ifma)
		}
	}
	return ifmat
}