Pull request: * all: move internal Go packages to internal/

Merge in DNS/adguard-home from 2234-move-to-internal to master

Squashed commit of the following:

commit d26a288cabeac86f9483fab307677b1027c78524
Author: Eugene Burkov <e.burkov@adguard.com>
Date:   Fri Oct 30 12:44:18 2020 +0300

    * all: move internal Go packages to internal/

    Closes #2234.

internal/util/network_utils.go

@@ -0,0 +1,186 @@
+package util
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"os"
+	"runtime"
+	"strconv"
+	"syscall"
+	"time"
+
+	"github.com/AdguardTeam/golibs/log"
+
+	"github.com/joomcode/errorx"
+)
+
+// NetInterface represents a list of network interfaces
+type NetInterface struct {
+	Name         string   // Network interface name
+	MTU          int      // MTU
+	HardwareAddr string   // Hardware address
+	Addresses    []string // Array with the network interface addresses
+	Subnets      []string // Array with CIDR addresses of this network interface
+	Flags        string   // Network interface flags (up, broadcast, etc)
+}
+
+// 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: %s", err)
+	}
+
+	netIfaces := []net.Interface{}
+
+	for i := range ifaces {
+		iface := ifaces[i]
+		netIfaces = append(netIfaces, iface)
+	}
+
+	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, errorx.Decorate(err, "Couldn't get interfaces")
+	}
+	if len(ifaces) == 0 {
+		return nil, errors.New("couldn't find any legible interface")
+	}
+
+	var netInterfaces []NetInterface
+
+	for _, iface := range ifaces {
+		addrs, e := iface.Addrs()
+		if e != nil {
+			return nil, errorx.Decorate(e, "Failed to get addresses for interface %s", iface.Name)
+		}
+
+		netIface := NetInterface{
+			Name:         iface.Name,
+			MTU:          iface.MTU,
+			HardwareAddr: iface.HardwareAddr.String(),
+		}
+
+		if iface.Flags != 0 {
+			netIface.Flags = iface.Flags.String()
+		}
+
+		// Collect network interface addresses
+		for _, addr := range addrs {
+			ipNet, ok := addr.(*net.IPNet)
+			if !ok {
+				// not an IPNet, should not happen
+				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.String())
+			netIface.Subnets = append(netIface.Subnets, ipNet.String())
+		}
+
+		// Discard interfaces with no addresses
+		if len(netIface.Addresses) != 0 {
+			netInterfaces = append(netInterfaces, netIface)
+		}
+	}
+
+	return netInterfaces, nil
+}
+
+// GetInterfaceByIP - Get interface name by its IP address.
+func GetInterfaceByIP(ip string) 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 - Get IP address with netmask for the specified interface
+// Returns an empty string if it fails to find it
+func GetSubnet(ifaceName string) string {
+	netIfaces, err := GetValidNetInterfacesForWeb()
+	if err != nil {
+		log.Error("Could not get network interfaces info: %v", err)
+		return ""
+	}
+
+	for _, netIface := range netIfaces {
+		if netIface.Name == ifaceName && len(netIface.Subnets) > 0 {
+			return netIface.Subnets[0]
+		}
+	}
+
+	return ""
+}
+
+// CheckPortAvailable - check if TCP port is available
+func CheckPortAvailable(host string, port int) error {
+	ln, err := net.Listen("tcp", net.JoinHostPort(host, 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 string, port int) error {
+	ln, err := net.ListenPacket("udp", net.JoinHostPort(host, 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
+}