// Package aghnet contains some utilities for networking. package aghnet import ( "bytes" "encoding/json" "fmt" "io" "net" "net/netip" "syscall" "github.com/AdguardTeam/AdGuardHome/internal/aghos" "github.com/AdguardTeam/golibs/errors" "github.com/AdguardTeam/golibs/log" ) // Variables and functions to substitute in tests. var ( // aghosRunCommand is the function to run shell commands. aghosRunCommand = aghos.RunCommand // netInterfaces is the function to get the available network interfaces. netInterfaceAddrs = net.InterfaceAddrs // rootDirFS is the filesystem pointing to the root directory. rootDirFS = aghos.RootDirFS() ) // ErrNoStaticIPInfo is returned by IfaceHasStaticIP when no information about // the IP being static is available. const ErrNoStaticIPInfo errors.Error = "no information about static ip" // IPv4Localhost returns 127.0.0.1, which returns true for [netip.Addr.Is4]. func IPv4Localhost() (ip netip.Addr) { return netip.AddrFrom4([4]byte{127, 0, 0, 1}) } // IPv6Localhost returns ::1, which returns true for [netip.Addr.Is6]. func IPv6Localhost() (ip netip.Addr) { return netip.AddrFrom16([16]byte{15: 1}) } // IfaceHasStaticIP checks if interface is configured to have static IP address. // If it can't give a definitive answer, it returns false and an error for which // errors.Is(err, ErrNoStaticIPInfo) is true. func IfaceHasStaticIP(ifaceName string) (has bool, err error) { return ifaceHasStaticIP(ifaceName) } // IfaceSetStaticIP sets static IP address for network interface. func IfaceSetStaticIP(ifaceName string) (err error) { return ifaceSetStaticIP(ifaceName) } // GatewayIP returns IP address of interface's gateway. // // TODO(e.burkov): Investigate if the gateway address may be fetched in another // way since not every machine has the software installed. func GatewayIP(ifaceName string) (ip netip.Addr) { code, out, err := aghosRunCommand("ip", "route", "show", "dev", ifaceName) if err != nil { log.Debug("%s", err) return netip.Addr{} } else if code != 0 { log.Debug("fetching gateway ip: unexpected exit code: %d", code) return netip.Addr{} } fields := bytes.Fields(out) // The meaningful "ip route" command output should contain the word // "default" at first field and default gateway IP address at third field. if len(fields) < 3 || string(fields[0]) != "default" { return netip.Addr{} } ip, err = netip.ParseAddr(string(fields[2])) if err != nil { return netip.Addr{} } return ip } // CanBindPrivilegedPorts checks if current process can bind to privileged // ports. func CanBindPrivilegedPorts() (can bool, err error) { return canBindPrivilegedPorts() } // NetInterface represents an entry of network interfaces map. type NetInterface struct { // Addresses are the network interface addresses. Addresses []netip.Addr `json:"ip_addresses,omitempty"` // Subnets are the IP networks for this network interface. Subnets []netip.Prefix `json:"-"` Name string `json:"name"` HardwareAddr net.HardwareAddr `json:"hardware_address"` Flags net.Flags `json:"flags"` MTU int `json:"mtu"` } // MarshalJSON implements the json.Marshaler interface for NetInterface. func (iface NetInterface) MarshalJSON() ([]byte, error) { type netInterface NetInterface return json.Marshal(&struct { HardwareAddr string `json:"hardware_address"` Flags string `json:"flags"` netInterface }{ HardwareAddr: iface.HardwareAddr.String(), Flags: iface.Flags.String(), netInterface: netInterface(iface), }) } func NetInterfaceFrom(iface *net.Interface) (niface *NetInterface, err error) { niface = &NetInterface{ Name: iface.Name, HardwareAddr: iface.HardwareAddr, Flags: iface.Flags, MTU: iface.MTU, } addrs, err := iface.Addrs() if err != nil { return nil, fmt.Errorf("failed to get addresses for interface %s: %w", iface.Name, err) } // Collect network interface addresses. for _, addr := range addrs { n, ok := addr.(*net.IPNet) if !ok { // Should be *net.IPNet, this is weird. return nil, fmt.Errorf("expected %[2]s to be %[1]T, got %[2]T", n, addr) } else if ip4 := n.IP.To4(); ip4 != nil { n.IP = ip4 } ip, ok := netip.AddrFromSlice(n.IP) if !ok { return nil, fmt.Errorf("bad address %s", n.IP) } ip = ip.Unmap() if ip.IsLinkLocalUnicast() { // Ignore link-local IPv4. if ip.Is4() { continue } ip = ip.WithZone(iface.Name) } ones, _ := n.Mask.Size() p := netip.PrefixFrom(ip, ones) niface.Addresses = append(niface.Addresses, ip) niface.Subnets = append(niface.Subnets, p) } return niface, nil } // GetValidNetInterfacesForWeb returns interfaces that are eligible for DNS and // WEB only we do not return link-local addresses here. // // TODO(e.burkov): Can't properly test the function since it's nontrivial to // substitute net.Interface.Addrs and the net.InterfaceAddrs can't be used. func GetValidNetInterfacesForWeb() (nifaces []*NetInterface, err error) { ifaces, err := net.Interfaces() if err != nil { return nil, fmt.Errorf("getting interfaces: %w", err) } else if len(ifaces) == 0 { return nil, errors.Error("no legible interfaces") } for i := range ifaces { var niface *NetInterface niface, err = NetInterfaceFrom(&ifaces[i]) if err != nil { return nil, err } else if len(niface.Addresses) != 0 { // Discard interfaces with no addresses. nifaces = append(nifaces, niface) } } return nifaces, nil } // InterfaceByIP returns the name of the interface bound to ip. // // TODO(a.garipov, e.burkov): This function is technically incorrect, since one // IP address can be shared by multiple interfaces in some configurations. // // TODO(e.burkov): See TODO on GetValidNetInterfacesForWeb. func InterfaceByIP(ip netip.Addr) (ifaceName string) { ifaces, err := GetValidNetInterfacesForWeb() if err != nil { return "" } for _, iface := range ifaces { for _, addr := range iface.Addresses { if ip == addr { return iface.Name } } } return "" } // GetSubnet returns the subnet corresponding to the interface of zero prefix if // the search fails. // // TODO(e.burkov): See TODO on GetValidNetInterfacesForWeb. func GetSubnet(ifaceName string) (p netip.Prefix) { netIfaces, err := GetValidNetInterfacesForWeb() if err != nil { log.Error("Could not get network interfaces info: %v", err) return p } for _, netIface := range netIfaces { if netIface.Name == ifaceName && len(netIface.Subnets) > 0 { return netIface.Subnets[0] } } return p } // CheckPort checks if the port is available for binding. network is expected // to be one of "udp" and "tcp". func CheckPort(network string, ipp netip.AddrPort) (err error) { var c io.Closer addr := ipp.String() switch network { case "tcp": c, err = net.Listen(network, addr) case "udp": c, err = net.ListenPacket(network, addr) default: return nil } if err != nil { return err } return closePortChecker(c) } // IsAddrInUse checks if err is about unsuccessful address binding. func IsAddrInUse(err error) (ok bool) { var sysErr syscall.Errno if !errors.As(err, &sysErr) { return false } return isAddrInUse(sysErr) } // CollectAllIfacesAddrs returns the slice of all network interfaces IP // addresses without port number. func CollectAllIfacesAddrs() (addrs []string, err error) { var ifaceAddrs []net.Addr ifaceAddrs, err = netInterfaceAddrs() if err != nil { return nil, fmt.Errorf("getting interfaces addresses: %w", err) } for _, addr := range ifaceAddrs { cidr := addr.String() var ip net.IP ip, _, err = net.ParseCIDR(cidr) if err != nil { return nil, fmt.Errorf("parsing cidr: %w", err) } addrs = append(addrs, ip.String()) } return addrs, nil } // BroadcastFromPref calculates the broadcast IP address for p. func BroadcastFromPref(p netip.Prefix) (bc netip.Addr) { bc = p.Addr().Unmap() if !bc.IsValid() { return netip.Addr{} } maskLen, addrLen := p.Bits(), bc.BitLen() if maskLen == addrLen { return bc } ipBytes := bc.AsSlice() for i := maskLen; i < addrLen; i++ { ipBytes[i/8] |= 1 << (7 - (i % 8)) } bc, _ = netip.AddrFromSlice(ipBytes) return bc }