mirror of
https://github.com/AdguardTeam/AdGuardHome.git
synced 2024-12-17 13:11:42 +03:00
3b2f5d7842
Merge in DNS/adguard-home from 2704-local-addresses-vol.1 to master Updates #2704. Updates #2829. Updates #2846. Squashed commit of the following: commit 9a49b3d27edcb30da7f16a065226907833b1dc81 Author: Eugene Burkov <e.burkov@adguard.com> Date: Mon Mar 22 15:39:17 2021 +0300 aghnet: imp docs and logging commit 74f95a29c55b9e732276601b0ecc63fb7c3a9f9e Author: Eugene Burkov <e.burkov@adguard.com> Date: Fri Mar 19 20:56:51 2021 +0300 all: fix friday evening mistakes commit 0e2066bc5c16ed807fa601780b99e154502361a9 Author: Eugene Burkov <e.burkov@adguard.com> Date: Fri Mar 19 20:51:15 2021 +0300 all: upd testify, imp code quality commit 8237c50b670c58361ccf7adec3ff2452b1196677 Author: Eugene Burkov <e.burkov@adguard.com> Date: Fri Mar 19 20:19:29 2021 +0300 aghnet: imp test naming commit 14eb1e189339554c0a6d38e2ba7a93917774ebab Author: Eugene Burkov <e.burkov@adguard.com> Date: Fri Mar 19 19:41:43 2021 +0300 aghnet: isolate windows-specific functionality commit d461ac8b18c187999da3e3aba116571b7ebe6785 Author: Eugene Burkov <e.burkov@adguard.com> Date: Fri Mar 19 14:50:05 2021 +0300 aghnet: imp code quality commit d0ee01cb1f8613de2085c0f2f2f396e46beb52a5 Author: Eugene Burkov <e.burkov@adguard.com> Date: Fri Mar 19 11:59:10 2021 +0300 all: mv funcs to agherr, mk system resolvers getter
276 lines
7.3 KiB
Go
276 lines
7.3 KiB
Go
// Package aghnet contains some utilities for networking.
|
|
package aghnet
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"net"
|
|
"os"
|
|
"os/exec"
|
|
"runtime"
|
|
"strconv"
|
|
"strings"
|
|
"syscall"
|
|
"time"
|
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/agherr"
|
|
"github.com/AdguardTeam/golibs/log"
|
|
)
|
|
|
|
// ErrNoStaticIPInfo is returned by IfaceHasStaticIP when no information about
|
|
// the IP being static is available.
|
|
const ErrNoStaticIPInfo agherr.Error = "no information about static ip"
|
|
|
|
// 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.
|
|
func GatewayIP(ifaceName string) net.IP {
|
|
cmd := exec.Command("ip", "route", "show", "dev", ifaceName)
|
|
log.Tracef("executing %s %v", cmd.Path, cmd.Args)
|
|
d, err := cmd.Output()
|
|
if err != nil || cmd.ProcessState.ExitCode() != 0 {
|
|
return nil
|
|
}
|
|
|
|
fields := strings.Fields(string(d))
|
|
// 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 || fields[0] != "default" {
|
|
return nil
|
|
}
|
|
|
|
return net.ParseIP(fields[2])
|
|
}
|
|
|
|
// CanBindPort checks if we can bind to the given port.
|
|
func CanBindPort(port int) (can bool, err error) {
|
|
var addr *net.TCPAddr
|
|
addr, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("127.0.0.1:%d", port))
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
var listener *net.TCPListener
|
|
listener, err = net.ListenTCP("tcp", addr)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
_ = listener.Close()
|
|
return true, nil
|
|
}
|
|
|
|
// NetInterface represents an entry of network interfaces map.
|
|
type NetInterface struct {
|
|
MTU int `json:"mtu"`
|
|
Name string `json:"name"`
|
|
HardwareAddr net.HardwareAddr `json:"hardware_address"`
|
|
Flags net.Flags `json:"flags"`
|
|
// Array with the network interface addresses.
|
|
Addresses []net.IP `json:"ip_addresses,omitempty"`
|
|
// Array with IP networks for this network interface.
|
|
Subnets []*net.IPNet `json:"-"`
|
|
}
|
|
|
|
// 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),
|
|
})
|
|
}
|
|
|
|
// GetValidNetInterfaces returns interfaces that are eligible for DNS and/or DHCP
|
|
// invalid interface is a ppp interface or the one that doesn't allow broadcasts
|
|
func GetValidNetInterfaces() ([]net.Interface, error) {
|
|
ifaces, err := net.Interfaces()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("couldn't get list of interfaces: %w", err)
|
|
}
|
|
|
|
netIfaces := []net.Interface{}
|
|
|
|
netIfaces = append(netIfaces, ifaces...)
|
|
|
|
return netIfaces, nil
|
|
}
|
|
|
|
// GetValidNetInterfacesForWeb returns interfaces that are eligible for DNS and WEB only
|
|
// we do not return link-local addresses here
|
|
func GetValidNetInterfacesForWeb() ([]*NetInterface, error) {
|
|
ifaces, err := GetValidNetInterfaces()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("couldn't get interfaces: %w", err)
|
|
}
|
|
if len(ifaces) == 0 {
|
|
return nil, errors.New("couldn't find any legible interface")
|
|
}
|
|
|
|
var netInterfaces []*NetInterface
|
|
|
|
for _, iface := range ifaces {
|
|
var addrs []net.Addr
|
|
addrs, err = iface.Addrs()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get addresses for interface %s: %w", iface.Name, err)
|
|
}
|
|
|
|
netIface := &NetInterface{
|
|
MTU: iface.MTU,
|
|
Name: iface.Name,
|
|
HardwareAddr: iface.HardwareAddr,
|
|
Flags: iface.Flags,
|
|
}
|
|
|
|
// Collect network interface addresses.
|
|
for _, addr := range addrs {
|
|
ipNet, ok := addr.(*net.IPNet)
|
|
if !ok {
|
|
// Should be net.IPNet, this is weird.
|
|
return nil, fmt.Errorf("got iface.Addrs() element %s that is not net.IPNet, it is %T", addr, addr)
|
|
}
|
|
// Ignore link-local.
|
|
if ipNet.IP.IsLinkLocalUnicast() {
|
|
continue
|
|
}
|
|
netIface.Addresses = append(netIface.Addresses, ipNet.IP)
|
|
netIface.Subnets = append(netIface.Subnets, ipNet)
|
|
}
|
|
|
|
// Discard interfaces with no addresses.
|
|
if len(netIface.Addresses) != 0 {
|
|
netInterfaces = append(netInterfaces, netIface)
|
|
}
|
|
}
|
|
|
|
return netInterfaces, nil
|
|
}
|
|
|
|
// GetInterfaceByIP returns the name of interface containing provided ip.
|
|
func GetInterfaceByIP(ip net.IP) string {
|
|
ifaces, err := GetValidNetInterfacesForWeb()
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
|
|
for _, iface := range ifaces {
|
|
for _, addr := range iface.Addresses {
|
|
if ip.Equal(addr) {
|
|
return iface.Name
|
|
}
|
|
}
|
|
}
|
|
|
|
return ""
|
|
}
|
|
|
|
// GetSubnet returns pointer to net.IPNet for the specified interface or nil if
|
|
// the search fails.
|
|
func GetSubnet(ifaceName string) *net.IPNet {
|
|
netIfaces, err := GetValidNetInterfacesForWeb()
|
|
if err != nil {
|
|
log.Error("Could not get network interfaces info: %v", err)
|
|
return nil
|
|
}
|
|
|
|
for _, netIface := range netIfaces {
|
|
if netIface.Name == ifaceName && len(netIface.Subnets) > 0 {
|
|
return netIface.Subnets[0]
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// CheckPortAvailable - check if TCP port is available
|
|
func CheckPortAvailable(host net.IP, port int) error {
|
|
ln, err := net.Listen("tcp", net.JoinHostPort(host.String(), strconv.Itoa(port)))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_ = ln.Close()
|
|
|
|
// It seems that net.Listener.Close() doesn't close file descriptors right away.
|
|
// We wait for some time and hope that this fd will be closed.
|
|
time.Sleep(100 * time.Millisecond)
|
|
return nil
|
|
}
|
|
|
|
// CheckPacketPortAvailable - check if UDP port is available
|
|
func CheckPacketPortAvailable(host net.IP, port int) error {
|
|
ln, err := net.ListenPacket("udp", net.JoinHostPort(host.String(), strconv.Itoa(port)))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_ = ln.Close()
|
|
|
|
// It seems that net.Listener.Close() doesn't close file descriptors right away.
|
|
// We wait for some time and hope that this fd will be closed.
|
|
time.Sleep(100 * time.Millisecond)
|
|
return err
|
|
}
|
|
|
|
// ErrorIsAddrInUse - check if error is "address already in use"
|
|
func ErrorIsAddrInUse(err error) bool {
|
|
errOpError, ok := err.(*net.OpError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
|
|
errSyscallError, ok := errOpError.Err.(*os.SyscallError)
|
|
if !ok {
|
|
return false
|
|
}
|
|
|
|
errErrno, ok := errSyscallError.Err.(syscall.Errno)
|
|
if !ok {
|
|
return false
|
|
}
|
|
|
|
if runtime.GOOS == "windows" {
|
|
const WSAEADDRINUSE = 10048
|
|
return errErrno == WSAEADDRINUSE
|
|
}
|
|
|
|
return errErrno == syscall.EADDRINUSE
|
|
}
|
|
|
|
// SplitHost is a wrapper for net.SplitHostPort for the cases when the hostport
|
|
// does not necessarily contain a port.
|
|
func SplitHost(hostport string) (host string, err error) {
|
|
host, _, err = net.SplitHostPort(hostport)
|
|
if err != nil {
|
|
// Check for the missing port error. If it is that error, just
|
|
// use the host as is.
|
|
//
|
|
// See the source code for net.SplitHostPort.
|
|
const missingPort = "missing port in address"
|
|
|
|
addrErr := &net.AddrError{}
|
|
if !errors.As(err, &addrErr) || addrErr.Err != missingPort {
|
|
return "", err
|
|
}
|
|
|
|
host = hostport
|
|
}
|
|
|
|
return host, nil
|
|
}
|