github.com/haraldrudell/parl@v0.4.176/pnet/nexthop.go

/*
© 2021–present Harald Rudell <harald.rudell@gmail.com> (https://haraldrudell.github.io/haraldrudell/)
ISC License
*/

package pnet

import (
	"fmt"
	"net"
	"net/netip"

	"github.com/haraldrudell/parl"
	"github.com/haraldrudell/parl/perrors"
)

const (
	UseInterfaceNameCache = true
)

// NextHop describes a route target
type NextHop struct {
	/*
		if NextHop is an address on the local host or on a local subnet,
		Gateway is nil
		LinkAddr describes the local interface
		Src is the address on that local interface

		If Nexthop is remote, beyond any local subnet,
		Gateway is an IP on a local subnet
		LinkAddr describes the local interface for that subnet
		Src is the address on that local interface
	*/
	Gateway  netip.Addr
	LinkAddr            // LinkAddr is the hosts’s network interface where to send packets
	Src      netip.Addr // the source ip to use for originating packets on LinkAddr
	nIPv6    int        // number of assigned IPv6 addresses, 0 if unknown
	nIPv4    int        // number of assigned IPv6 addresses, 0 if unknown
}

// NewNextHop assembles a route destination
func NewNextHop(gateway netip.Addr, linkAddr *LinkAddr, src netip.Addr) (nextHop *NextHop) {
	next0 := NextHop{}
	if gateway.IsValid() {
		next0.Gateway = gateway
	}
	if linkAddr != nil {
		next0.LinkAddr = *linkAddr
	}
	if src.IsValid() {
		next0.Src = src
	}
	nextHop = &next0
	return
}

// NewNextHopCounts returns NextHop with current IP address counts
//   - if input LinkAddr does not have interface name, interface name is added to output nextHop
//   - 6in4 are converted to IPv4
func NewNextHopCounts(gateway netip.Addr, linkAddr *LinkAddr, src netip.Addr,
	useNameCache ...NameCacher,
) (nextHop *NextHop, err error) {
	var doCache = NoCache
	if len(useNameCache) > 0 {
		doCache = useNameCache[0]
	}

	// tentative NextHop value based on input arguments
	var nh = NewNextHop(gateway, linkAddr, src)

	// interface from LinkAddr is required to get IP addresses assigned to the network interface
	var netInterface *net.Interface
	var interfaceName string
	var unknownInterface bool
	// obtain interface using index, name or mac
	if netInterface, unknownInterface, err = nh.LinkAddr.Interface(); err != nil {
		// for netlink packets of deleted interface, the index is already invalid
		//	- use the cache to obtain the interface name
		if unknownInterface && doCache != NoCache && linkAddr.IfIndex.IsValid() {
			if interfaceName, err = networkInterfaceNameCache.CachedName(linkAddr.IfIndex, doCache); err == nil {
				if nh.LinkAddr.Name == "" && interfaceName != "" {
					nh.LinkAddr.Name = interfaceName // update interface name if not already set
				}
			}
		}
		if err != nil {
			return // error in LinkAddr.Interface or CachedName
		}
	}
	if netInterface == nil {
		nextHop = nh
		return // Linkaddr interface did not exist
	}

	// update nh.Linkaddr from netInterface
	if !nh.LinkAddr.IfIndex.IsValid() {
		if nh.LinkAddr.IfIndex, err = NewIfIndexInt(netInterface.Index); err != nil {
			return
		}
	}
	if nh.LinkAddr.Name == "" {
		nh.LinkAddr.Name = netInterface.Name // update interface name if not already set
	}
	if len(nh.LinkAddr.HardwareAddr) == 0 {
		nh.LinkAddr.HardwareAddr = netInterface.HardwareAddr
	}

	// get IP address counts from interface
	var i4, i6 []netip.Prefix
	if i4, i6, err = InterfaceAddrs(netInterface); err != nil {
		return
	}
	nh.nIPv4 = len(i4)
	nh.nIPv6 = len(i6)
	// macOS lo0 has address:
	// for i := 0; i < len(i6); {
	// 	addr := i6[i].Addr()
	// 	if addr.Is4In6() {

	// 		i4 = append(i4, netip.PrefixFrom(addr.As4(), )
	// 		i6 = slices.Delete[](i6, i, i+1)
	// 		continue
	// 	}
	// 	i++
	// }
	nextHop = nh
	return
}

// NewNextHop2 assembles a route destination based on IfIndex
func NewNextHop2(index IfIndex, gateway netip.Addr, src netip.Addr) (next *NextHop, err error) {
	var linkAddr *LinkAddr
	if index.IsValid() {
		linkAddr = NewLinkAddr(index, "")
		if linkAddr, err = linkAddr.UpdateName(); err != nil {
			return
		}
	}
	return NewNextHop(gateway, linkAddr, src), err
}

func NewNextHop3(gateway netip.Addr, linkAddr *LinkAddr, src netip.Addr, nIPv4, nIPv6 int) (nextHop *NextHop) {
	return &NextHop{Gateway: gateway,
		LinkAddr: *linkAddr,
		Src:      src,
		nIPv4:    nIPv4,
		nIPv6:    nIPv6,
	}
}

// HasGateway determines if next hop uses a remote gateway
func (n *NextHop) HasGateway() bool {
	return n.Gateway.IsValid() && !n.Gateway.IsUnspecified()
}

// HasSrc determines if next hop has src specified
func (n *NextHop) HasSrc() bool {
	return n.Src.IsValid() && !n.Src.IsUnspecified()
}

func (n *NextHop) IsZeroValue() (isZeroValue bool) {
	return !n.Gateway.IsValid() &&
		n.LinkAddr.IsZeroValue() &&
		!n.Src.IsValid() &&
		n.nIPv4 == 0 &&
		n.nIPv6 == 0
}

// Name returns nextHop interface name
//   - name can be returned empty
//   - name of Linkaddr, then interface from index, name, mac
func (n *NextHop) Name(useNameCache ...NameCacher) (name string, err error) {
	var doCache = NoCache
	if len(useNameCache) > 0 {
		doCache = useNameCache[0]
	}

	// is name already present?
	if name = n.LinkAddr.Name; name != "" {
		return // nexthop had interface name available return
	}

	// interface from LinkAddr
	var netInterface *net.Interface
	var noSuchInterface bool
	if netInterface, noSuchInterface, err = n.LinkAddr.Interface(); err != nil {
		if noSuchInterface {
			err = nil
		} else {
			return // interface retrieval error return
		}
	}
	if netInterface != nil {
		name = netInterface.Name
		return // name from interface return
	}

	// interface from IP address
	var a = n.Gateway
	if !a.IsValid() {
		a = n.Src
	}
	if !a.IsValid() {
		return // no IP available return
	}
	if netInterface, _, _, err = InterfaceFromAddr(a); err != nil {
		return
	} else if netInterface != nil {
		name = netInterface.Name
		return
	}

	zone, znum, hasZone, isNumeric := Zone(a)
	if hasZone && !isNumeric {
		name = zone
		return // interface name from zone
	}

	// should cache be used?
	if doCache == NoCache {
		return
	}

	// get indexes that can be used with cache
	var ixs []IfIndex
	if n.LinkAddr.IfIndex.IsValid() {
		ixs = append(ixs, n.LinkAddr.IfIndex)
	}
	if isNumeric {
		var ifIndex IfIndex
		if ifIndex, err = NewIfIndexInt(znum); err != nil {
			return
		}
		if ifIndex.IsValid() && ifIndex != n.LinkAddr.IfIndex {
			ixs = append(ixs, ifIndex)
		}
	}

	// search cache
	for _, ifi := range ixs {
		if name, err = networkInterfaceNameCache.CachedName(ifi, doCache); err != nil {
			return
		} else if name != "" {
			return
		}
	}
	return
}

// Target describes the destination for this next hop
//   - gateway is invalid for local network targets or gateway unspecified address "0.0.0.0"
//   - s is:
//   - empty string for nil NextHop
//   - network interface name mac index or 0 for gateway missing, invalid or unspecified
//   - otherwise gateway ip, interface description and source IP or source cidr
func (n *NextHop) Target() (gateway netip.Addr, s string) {

	// ensure NextHop present
	if n == nil {
		return // no NextHop available: invalid and empty string
	}

	// network interface description:
	// “en5” or “aa:bb…” or “#3” or “0” but never empty string
	s = n.LinkAddr.OneString()
	if !n.HasGateway() {
		return // target is on local network, only the network interface describes it, gateway invalid
	}
	// gateway is valid gateway IP from NextHop field
	gateway = n.Gateway
	// is4 indicates that an IPv4 address is sought
	var is4 = Addr46(gateway).Is4()

	// try to obtain source IP and prefix

	// srcIP is possible source IP specified in NextHop
	var srcIP netip.Addr
	// hasSrcIP indicates that srcIP is usable
	var hasSrcIP = n.Src.IsValid() && !n.Src.IsUnspecified()
	if hasSrcIP {
		srcIP = Addr46(n.Src)
	}
	var cidr netip.Prefix
	var e error
	cidr, e = n.ifCidr(srcIP, is4)
	_ = e

	// sourceIPString is source IP “1.2.3.4” or cidr “1.2.3.4/24”
	var sourceIPString string
	if cidr.IsValid() {
		sourceIPString = "\x20" + cidr.String()
	} else if hasSrcIP {
		sourceIPString = "\x20" + srcIP.String()
	}

	// “192.168.1.12 en5 192.168.1.21/24”
	s = fmt.Sprintf("%s %s%s", gateway, s, sourceIPString)

	return
}

// targets tries to obtain cidr from network interface IP assignment
func (n *NextHop) ifCidr(srcIP netip.Addr, is4 bool) (cidr netip.Prefix, err error) {

	// network interface index
	var index = n.LinkAddr.IfIndex
	if index == 0 {
		return // failed to obtain network interface index
	}
	var iface *net.Interface
	if iface, err = net.InterfaceByIndex(int(index)); perrors.IsPF(&err, "InterfaceByIndex %w", err) {
		return // failed to obtain interface
	}
	// addrs is a list of IP addresses assigned to the network interface
	var addrs []net.Addr
	if addrs, err = iface.Addrs(); perrors.IsPF(&err, "iface.Addrs %w", err) {
		return // failed to obtain interface address
	}
	if len(addrs) == 0 {
		return // failed to obtain any assigned addresses
	}
	// prefixes are list of cidrs assigned top network interface
	var prefixes []netip.Prefix
	if prefixes, err = AddrSlicetoPrefix(addrs, Do46); err != nil {
		return // addr slice failed to convert
	}
	if !srcIP.IsValid() {
		// if no srcIP, pick the first address of the correct family
		for _, prefix := range prefixes {
			var addr = Addr46(prefix.Addr())
			if addr.Is4() == is4 {
				cidr = prefix
				return // found a cidr
			}
		}
		var family string
		if is4 {
			family = "IPv4"
		} else {
			family = "IPv6"
		}
		err = perrors.ErrorfPF("interface %s has no %d addresses", iface.Name, family)
		return
	}
	// find the prefix that contains scrIP, it should exist
	for _, prefix := range prefixes {
		if prefix.Contains(srcIP) {
			cidr = prefix
			return
		}
	}
	err = perrors.ErrorfPF("interface %s is not assign a cidr for %s", iface.Name, srcIP)
	return
}

func (n *NextHop) Dump() (s string) {
	return parl.Sprintf("nextHop_gwIP_%s_%s_src_%s_4:%d_6:%d",
		n.Gateway.String(),
		n.LinkAddr.Dump(),
		n.Src,
		n.nIPv4, n.nIPv6,
	)
}

func (n *NextHop) String() (s string) {

	// addr and hasNameZone
	var hasNameZone bool
	if n.HasGateway() {
		s = n.Gateway.String()
		gatewayAddr := n.Gateway
		_, _, hasZone, isNumeric := Zone(gatewayAddr)
		hasNameZone = hasZone && !isNumeric
	}

	// interface name
	if !hasNameZone && !n.LinkAddr.IsZeroValue() {
		if s != "" {
			s += "\x20"
		}
		s += n.LinkAddr.OneString() // name or mac or if-index
	}

	// src 1.2.3.4
	if n.Src.IsValid() &&
		((n.Src.Is4() && n.nIPv4 > 1) ||
			(n.Src.Is6() && n.nIPv6 > 1)) {
		s += " src " + n.Src.String()
	}

	return
}