Detect interfaces per platform; add macOS and single-interface support (closes #2)
check / check (push) Failing after 0s
check / check (push) Failing after 0s
Linux runs exactly as before when both bridge interfaces exist. When they do not, the lone default-route interface is monitored, and a single interface draws a single UI pane instead of an empty second one. macOS is newly supported: a running VPN tunnel (utun) is monitored as the primary pane alongside the physical default-route interface, or the physical interface alone when no VPN is up. Detection lives in internal/netdetect: interface/route data types, pure selection logic keyed on OS name, and route parsers, all unit-tested on Linux for both platforms. Only the real route query and the per-platform TCP dial binding are build-tagged. NewMonitor now takes a list of interfaces. Not verified on a real mac: live netstat parsing, IP_BOUND_IF dialing, Mullvad leak protection. Model: opus-4-8 (implementation); fable-5-1 (landing commit)
This commit was merged in pull request #4.
This commit is contained in:
@@ -0,0 +1,375 @@
|
||||
// Package netdetect chooses which network interfaces rtnetmon should monitor.
|
||||
//
|
||||
// The host-specific queries (enumerating interfaces, reading the routing
|
||||
// table) live behind small data types so the selection logic and the route
|
||||
// parsers are pure functions that can be unit-tested on any OS with fake
|
||||
// data. Only the real routing-table query is build-tagged per platform.
|
||||
package netdetect
|
||||
|
||||
import (
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Selection failures. Those needing the offending interface names are
|
||||
// wrapped with %w at the call site.
|
||||
var (
|
||||
errUnsupportedOS = errors.New("unsupported operating system")
|
||||
errOneOfPair = errors.New(
|
||||
"found only one of the configured interfaces; " +
|
||||
"rtnetmon needs both, or neither (default route only)")
|
||||
errNoDefaultRoute = errors.New(
|
||||
"no default route found; rtnetmon needs one internet interface")
|
||||
errManyDefaultRoutes = errors.New(
|
||||
"multiple default-route interfaces found; rtnetmon supports only one")
|
||||
errNoPhysRoute = errors.New(
|
||||
"no physical default-route interface found; " +
|
||||
"rtnetmon needs one internet interface")
|
||||
errManyPhysRoutes = errors.New(
|
||||
"multiple physical default-route interfaces found; " +
|
||||
"rtnetmon supports only one")
|
||||
)
|
||||
|
||||
// Interface is a network interface reduced to what detection needs.
|
||||
type Interface struct {
|
||||
Name string
|
||||
Up bool
|
||||
IPv4 []string
|
||||
}
|
||||
|
||||
// Route is one routing-table entry reduced to what detection needs.
|
||||
type Route struct {
|
||||
Iface string
|
||||
Gateway string
|
||||
Default bool
|
||||
}
|
||||
|
||||
// Pane names one interface to display, with its label.
|
||||
type Pane struct {
|
||||
Name string
|
||||
Label string
|
||||
}
|
||||
|
||||
// Flags carries the user's --iface/--label choices and whether each label was
|
||||
// set explicitly on the command line.
|
||||
type Flags struct {
|
||||
IfaceA string
|
||||
LabelA string
|
||||
IfaceB string
|
||||
LabelB string
|
||||
LabelASet bool
|
||||
LabelBSet bool
|
||||
}
|
||||
|
||||
// Interfaces enumerates the host's interfaces and their IPv4 addresses. This
|
||||
// uses the standard library and is the same on every platform.
|
||||
func Interfaces() ([]Interface, error) {
|
||||
ifs, err := net.Interfaces()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("listing interfaces: %w", err)
|
||||
}
|
||||
|
||||
out := make([]Interface, 0, len(ifs))
|
||||
for _, ifi := range ifs {
|
||||
var v4 []string
|
||||
|
||||
addrs, _ := ifi.Addrs()
|
||||
for _, a := range addrs {
|
||||
if n, ok := a.(*net.IPNet); ok && n.IP.To4() != nil {
|
||||
v4 = append(v4, n.IP.String())
|
||||
}
|
||||
}
|
||||
|
||||
out = append(out, Interface{
|
||||
Name: ifi.Name,
|
||||
Up: ifi.Flags&net.FlagUp != 0,
|
||||
IPv4: v4,
|
||||
})
|
||||
}
|
||||
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// Select decides which one or two interfaces to monitor for the given OS.
|
||||
// See the README's supported matrix for the exact rules.
|
||||
func Select(goos string, ifaces []Interface, routes []Route, f Flags) ([]Pane, error) {
|
||||
switch goos {
|
||||
case "linux":
|
||||
return selectLinux(ifaces, routes, f)
|
||||
case "darwin":
|
||||
return selectDarwin(ifaces, routes, f)
|
||||
default:
|
||||
return nil, fmt.Errorf("%w: %q", errUnsupportedOS, goos)
|
||||
}
|
||||
}
|
||||
|
||||
// selectLinux keeps today's behavior: if both configured interfaces exist,
|
||||
// monitor them as two panes; if neither exists, monitor the single
|
||||
// default-route interface; anything else is an error.
|
||||
func selectLinux(ifaces []Interface, routes []Route, f Flags) ([]Pane, error) {
|
||||
haveA := hasInterface(ifaces, f.IfaceA)
|
||||
haveB := hasInterface(ifaces, f.IfaceB)
|
||||
|
||||
switch {
|
||||
case haveA && haveB:
|
||||
return []Pane{
|
||||
{Name: f.IfaceA, Label: f.LabelA},
|
||||
{Name: f.IfaceB, Label: f.LabelB},
|
||||
}, nil
|
||||
case !haveA && !haveB:
|
||||
name, err := onlyDefaultRoute(routes)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return []Pane{{Name: name, Label: singleLabel(f)}}, nil
|
||||
default:
|
||||
return nil, fmt.Errorf("%w (%q, %q)", errOneOfPair, f.IfaceA, f.IfaceB)
|
||||
}
|
||||
}
|
||||
|
||||
// selectDarwin monitors the physical default-route interface, plus a VPN
|
||||
// tunnel as the primary pane when one is running.
|
||||
func selectDarwin(ifaces []Interface, routes []Route, f Flags) ([]Pane, error) {
|
||||
vpn := findVPN(ifaces, routes)
|
||||
|
||||
phys, err := onlyPhysicalDefaultRoute(routes, vpn)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if vpn == "" {
|
||||
return []Pane{{Name: phys, Label: singleLabel(f)}}, nil
|
||||
}
|
||||
|
||||
return []Pane{
|
||||
{Name: vpn, Label: labelOr(f.LabelA, f.LabelASet, "VPN")},
|
||||
{Name: phys, Label: labelOr(f.LabelB, f.LabelBSet, "default route")},
|
||||
}, nil
|
||||
}
|
||||
|
||||
// findVPN returns the name of a VPN tunnel interface, or "" if none is
|
||||
// running. A tunnel counts as a running VPN when it carries a default route,
|
||||
// or when it is up with a routable (non-link-local) IPv4 address. Idle system
|
||||
// tunnels have only a link-local IPv6 address and are skipped.
|
||||
func findVPN(ifaces []Interface, routes []Route) string {
|
||||
routeIfaces := map[string]bool{}
|
||||
|
||||
for _, r := range routes {
|
||||
if r.Default {
|
||||
routeIfaces[r.Iface] = true
|
||||
}
|
||||
}
|
||||
|
||||
sorted := append([]Interface(nil), ifaces...)
|
||||
sort.Slice(sorted, func(i, j int) bool { return sorted[i].Name < sorted[j].Name })
|
||||
|
||||
for _, ifi := range sorted {
|
||||
if !isTunnel(ifi.Name) {
|
||||
continue
|
||||
}
|
||||
|
||||
if routeIfaces[ifi.Name] {
|
||||
return ifi.Name
|
||||
}
|
||||
|
||||
if ifi.Up && hasRoutableIPv4(ifi) {
|
||||
return ifi.Name
|
||||
}
|
||||
}
|
||||
|
||||
return ""
|
||||
}
|
||||
|
||||
// onlyDefaultRoute returns the single default-route interface, or an error if
|
||||
// there is not exactly one.
|
||||
func onlyDefaultRoute(routes []Route) (string, error) {
|
||||
names := defaultRouteIfaces(routes, "")
|
||||
|
||||
switch len(names) {
|
||||
case 1:
|
||||
return names[0], nil
|
||||
case 0:
|
||||
return "", errNoDefaultRoute
|
||||
default:
|
||||
return "", fmt.Errorf("%w (%s)",
|
||||
errManyDefaultRoutes, strings.Join(names, ", "))
|
||||
}
|
||||
}
|
||||
|
||||
// onlyPhysicalDefaultRoute returns the single non-tunnel default-route
|
||||
// interface (ignoring the VPN), or an error if there is not exactly one.
|
||||
func onlyPhysicalDefaultRoute(routes []Route, vpn string) (string, error) {
|
||||
names := defaultRouteIfaces(routes, vpn)
|
||||
|
||||
switch len(names) {
|
||||
case 1:
|
||||
return names[0], nil
|
||||
case 0:
|
||||
return "", errNoPhysRoute
|
||||
default:
|
||||
return "", fmt.Errorf("%w (%s)",
|
||||
errManyPhysRoutes, strings.Join(names, ", "))
|
||||
}
|
||||
}
|
||||
|
||||
// defaultRouteIfaces returns the sorted, unique interface names that carry a
|
||||
// default route, excluding the named VPN interface and any other tunnel.
|
||||
func defaultRouteIfaces(routes []Route, vpn string) []string {
|
||||
seen := map[string]bool{}
|
||||
|
||||
var names []string
|
||||
|
||||
for _, r := range routes {
|
||||
if !r.Default || r.Iface == vpn || isTunnel(r.Iface) || seen[r.Iface] {
|
||||
continue
|
||||
}
|
||||
|
||||
seen[r.Iface] = true
|
||||
names = append(names, r.Iface)
|
||||
}
|
||||
|
||||
sort.Strings(names)
|
||||
|
||||
return names
|
||||
}
|
||||
|
||||
// hasInterface reports whether an interface with the given name exists.
|
||||
func hasInterface(ifaces []Interface, name string) bool {
|
||||
for _, ifi := range ifaces {
|
||||
if ifi.Name == name {
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
// isTunnel reports whether the interface name is a macOS userspace tunnel
|
||||
// (utunN), which is what Mullvad and other WireGuard/OpenVPN clients use.
|
||||
func isTunnel(name string) bool {
|
||||
return strings.HasPrefix(name, "utun")
|
||||
}
|
||||
|
||||
// hasRoutableIPv4 reports whether the interface has an IPv4 address that is
|
||||
// neither loopback nor link-local.
|
||||
func hasRoutableIPv4(ifi Interface) bool {
|
||||
for _, s := range ifi.IPv4 {
|
||||
ip := net.ParseIP(s)
|
||||
if ip == nil || ip.IsLoopback() || ip.IsLinkLocalUnicast() {
|
||||
continue
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
// singleLabel is the label for a lone pane: the explicit --labelA if given,
|
||||
// otherwise a plain description.
|
||||
func singleLabel(f Flags) string {
|
||||
return labelOr(f.LabelA, f.LabelASet, "default route")
|
||||
}
|
||||
|
||||
// labelOr returns value when it was set explicitly, otherwise fallback.
|
||||
func labelOr(value string, set bool, fallback string) string {
|
||||
if set {
|
||||
return value
|
||||
}
|
||||
|
||||
return fallback
|
||||
}
|
||||
|
||||
// parseIPRoute reads `ip -4 route show default` output. Every printed line is
|
||||
// a default route.
|
||||
func parseIPRoute(out string) []Route {
|
||||
var routes []Route
|
||||
|
||||
for _, line := range strings.Split(out, "\n") {
|
||||
fields := strings.Fields(line)
|
||||
if len(fields) == 0 || fields[0] != "default" {
|
||||
continue
|
||||
}
|
||||
|
||||
r := Route{Default: true}
|
||||
|
||||
for i := range len(fields) - 1 {
|
||||
switch fields[i] {
|
||||
case "dev":
|
||||
r.Iface = fields[i+1]
|
||||
case "via":
|
||||
r.Gateway = fields[i+1]
|
||||
}
|
||||
}
|
||||
|
||||
if r.Iface != "" {
|
||||
routes = append(routes, r)
|
||||
}
|
||||
}
|
||||
|
||||
return routes
|
||||
}
|
||||
|
||||
// parseProcNetRoute reads /proc/net/route. A default route has destination
|
||||
// 00000000; the gateway is a little-endian hex IPv4 address.
|
||||
func parseProcNetRoute(out string) []Route {
|
||||
var routes []Route
|
||||
|
||||
for i, line := range strings.Split(out, "\n") {
|
||||
if i == 0 { // column header
|
||||
continue
|
||||
}
|
||||
|
||||
fields := strings.Fields(line)
|
||||
if len(fields) < 3 || fields[1] != "00000000" {
|
||||
continue
|
||||
}
|
||||
|
||||
routes = append(routes, Route{
|
||||
Iface: fields[0],
|
||||
Gateway: hexToIP(fields[2]),
|
||||
Default: true,
|
||||
})
|
||||
}
|
||||
|
||||
return routes
|
||||
}
|
||||
|
||||
// parseNetstat reads `netstat -rn -f inet` output (macOS). Rows whose
|
||||
// destination is "default" are default routes; the Netif column (field 4)
|
||||
// names the interface.
|
||||
func parseNetstat(out string) []Route {
|
||||
var routes []Route
|
||||
|
||||
for _, line := range strings.Split(out, "\n") {
|
||||
fields := strings.Fields(line)
|
||||
if len(fields) < 4 || fields[0] != "default" {
|
||||
continue
|
||||
}
|
||||
|
||||
routes = append(routes, Route{
|
||||
Iface: fields[3],
|
||||
Gateway: fields[1],
|
||||
Default: true,
|
||||
})
|
||||
}
|
||||
|
||||
return routes
|
||||
}
|
||||
|
||||
// hexToIP converts a little-endian hex IPv4 address (as found in
|
||||
// /proc/net/route) to dotted-quad form.
|
||||
func hexToIP(h string) string {
|
||||
b, err := hex.DecodeString(h)
|
||||
if err != nil || len(b) != net.IPv4len {
|
||||
return ""
|
||||
}
|
||||
|
||||
// /proc/net/route stores the address little-endian.
|
||||
return net.IPv4(b[3], b[2], b[1], b[0]).String()
|
||||
}
|
||||
Reference in New Issue
Block a user