//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
}