More interface reuse

Author: wwqgtxx

control/finder.go

@@ -0,0 +1,61 @@
+package control
+
+import (
+	"net"
+	"net/netip"
+	"unsafe"
+
+	"github.com/sagernet/sing/common"
+	M "github.com/sagernet/sing/common/metadata"
+
+	"golang.org/x/exp/slices"
+)
+
+type InterfaceFinder interface {
+	Update() error
+	Interfaces() []Interface
+	ByName(name string) (*Interface, error)
+	ByIndex(index int) (*Interface, error)
+	ByAddr(addr netip.Addr) (*Interface, error)
+}
+
+type Interface struct {
+	Index        int
+	MTU          int
+	Name         string
+	HardwareAddr net.HardwareAddr
+	Flags        net.Flags
+	Addresses    []netip.Prefix
+}
+
+func (i Interface) Equals(other Interface) bool {
+	return i.Index == other.Index &&
+		i.MTU == other.MTU &&
+		i.Name == other.Name &&
+		slices.Equal(i.HardwareAddr, other.HardwareAddr) &&
+		i.Flags == other.Flags &&
+		slices.Equal(i.Addresses, other.Addresses)
+}
+
+func (i Interface) NetInterface() net.Interface {
+	return *(*net.Interface)(unsafe.Pointer(&i))
+}
+
+func InterfaceFromNet(iif net.Interface) (Interface, error) {
+	ifAddrs, err := iif.Addrs()
+	if err != nil {
+		return Interface{}, err
+	}
+	return InterfaceFromNetAddrs(iif, common.Map(ifAddrs, M.PrefixFromNet)), nil
+}
+
+func InterfaceFromNetAddrs(iif net.Interface, addresses []netip.Prefix) Interface {
+	return Interface{
+		Index:        iif.Index,
+		MTU:          iif.MTU,
+		Name:         iif.Name,
+		HardwareAddr: iif.HardwareAddr,
+		Flags:        iif.Flags,
+		Addresses:    addresses,
+	}
+}

control/finder_default.go

@@ -0,0 +1,89 @@
+package control
+
+import (
+	"net"
+	"net/netip"
+
+	E "github.com/sagernet/sing/common/exceptions"
+)
+
+var _ InterfaceFinder = (*DefaultInterfaceFinder)(nil)
+
+type DefaultInterfaceFinder struct {
+	interfaces []Interface
+}
+
+func NewDefaultInterfaceFinder() *DefaultInterfaceFinder {
+	return &DefaultInterfaceFinder{}
+}
+
+func (f *DefaultInterfaceFinder) Update() error {
+	netIfs, err := net.Interfaces()
+	if err != nil {
+		return err
+	}
+	interfaces := make([]Interface, 0, len(netIfs))
+	for _, netIf := range netIfs {
+		var iif Interface
+		iif, err = InterfaceFromNet(netIf)
+		if err != nil {
+			return err
+		}
+		interfaces = append(interfaces, iif)
+	}
+	f.interfaces = interfaces
+	return nil
+}
+
+func (f *DefaultInterfaceFinder) UpdateInterfaces(interfaces []Interface) {
+	f.interfaces = interfaces
+}
+
+func (f *DefaultInterfaceFinder) Interfaces() []Interface {
+	return f.interfaces
+}
+
+func (f *DefaultInterfaceFinder) ByName(name string) (*Interface, error) {
+	for _, netInterface := range f.interfaces {
+		if netInterface.Name == name {
+			return &netInterface, nil
+		}
+	}
+	_, err := net.InterfaceByName(name)
+	if err == nil {
+		err = f.Update()
+		if err != nil {
+			return nil, err
+		}
+		return f.ByName(name)
+	}
+	return nil, &net.OpError{Op: "route", Net: "ip+net", Source: nil, Addr: &net.IPAddr{IP: nil}, Err: E.New("no such network interface")}
+}
+
+func (f *DefaultInterfaceFinder) ByIndex(index int) (*Interface, error) {
+	for _, netInterface := range f.interfaces {
+		if netInterface.Index == index {
+			return &netInterface, nil
+		}
+	}
+	_, err := net.InterfaceByIndex(index)
+	if err == nil {
+		err = f.Update()
+		if err != nil {
+			return nil, err
+		}
+		return f.ByIndex(index)
+	}
+	return nil, &net.OpError{Op: "route", Net: "ip+net", Source: nil, Addr: &net.IPAddr{IP: nil}, Err: E.New("no such network interface")}
+}
+
+func (f *DefaultInterfaceFinder) ByAddr(addr netip.Addr) (*Interface, error) {
+	for _, netInterface := range f.interfaces {
+		for _, prefix := range netInterface.Addresses {
+			if prefix.Contains(addr) {
+				return &netInterface, nil
+			}
+		}
+	}
+	return nil, &net.OpError{Op: "route", Net: "ip+net", Source: nil, Addr: &net.IPAddr{IP: addr.AsSlice()}, Err: E.New("no such network interface")}
+}

control/warpper.go

@@ -0,0 +1,66 @@
+package control
+
+import (
+	"net/netip"
+	"syscall"
+
+	"github.com/sagernet/sing/common"
+	"github.com/sagernet/sing/common/control"
+)
+
+func Append(oldFunc control.Func, newFunc control.Func) control.Func {
+	return control.Append(oldFunc, newFunc)
+}
+
+func BindToInterface0(finder InterfaceFinder, conn syscall.RawConn, network string, address string, interfaceName string, interfaceIndex int, preferInterfaceName bool) error {
+	return control.BindToInterface0(interfaceFinderWrapper{finder}, conn, network, address, interfaceName, interfaceIndex, preferInterfaceName)
+}
+
+type interfaceFinderWrapper struct {
+	finder InterfaceFinder
+}
+
+func (i interfaceFinderWrapper) Update() error {
+	return i.finder.Update()
+}
+
+func (i interfaceFinderWrapper) Interfaces() []control.Interface {
+	return common.Map(i.finder.Interfaces(), controlInterface)
+}
+
+func (i interfaceFinderWrapper) InterfaceIndexByName(name string) (int, error) {
+	if netIf, err := i.finder.ByName(name); err == nil {
+		return netIf.Index, nil
+	} else {
+		return 0, err
+	}
+}
+
+func (i interfaceFinderWrapper) InterfaceNameByIndex(index int) (string, error) {
+	if netIf, err := i.finder.ByIndex(index); err == nil {
+		return netIf.Name, nil
+	} else {
+		return "", err
+	}
+}
+
+func (i interfaceFinderWrapper) InterfaceByAddr(addr netip.Addr) (*control.Interface, error) {
+	if netIf, err := i.finder.ByAddr(addr); err == nil {
+		cif := controlInterface(*netIf)
+		return &cif, nil
+	} else {
+		return nil, err
+	}
+}
+
+var _ control.InterfaceFinder = &interfaceFinderWrapper{}
+
+func controlInterface(i Interface) control.Interface {
+	return control.Interface{
+		Index:        i.Index,
+		Name:         i.Name,
+		Flags:        i.Flags,
+		Addresses:    i.Addresses,
+		HardwareAddr: i.HardwareAddr,
+	}
+}

monitor.go

@@ -1,9 +1,7 @@
 package tun
 
 import (
-	"net/netip"
-
-	"github.com/sagernet/sing/common/control"
+	"github.com/metacubex/sing-tun/control"
 	E "github.com/sagernet/sing/common/exceptions"
 	"github.com/sagernet/sing/common/x/list"
 )
@@ -12,14 +10,10 @@ var ErrNoRoute = E.New("no route to internet")
 
 type (
 	NetworkUpdateCallback          = func()
-	DefaultInterfaceUpdateCallback = func(event int)
+	DefaultInterfaceUpdateCallback = func(defaultInterface *control.Interface, flags int)
 )
 
-const (
-	EventInterfaceUpdate  = 1
-	EventAndroidVPNUpdate = 2
-	EventNoRoute          = 4
-)
+const FlagAndroidVPNUpdate = 1 << iota
 
 type NetworkUpdateMonitor interface {
 	Start() error
@@ -31,9 +25,7 @@ type NetworkUpdateMonitor interface {
 type DefaultInterfaceMonitor interface {
 	Start() error
 	Close() error
-	DefaultInterfaceName(destination netip.Addr) string
-	DefaultInterfaceIndex(destination netip.Addr) int
-	DefaultInterface(destination netip.Addr) (string, int)
+	DefaultInterface() *control.Interface
 	OverrideAndroidVPN() bool
 	AndroidVPNEnabled() bool
 	RegisterCallback(callback DefaultInterfaceUpdateCallback) *list.Element[DefaultInterfaceUpdateCallback]

monitor_android.go

@@ -51,22 +51,21 @@ func (m *defaultInterfaceMonitor) checkUpdate() error {
 		return err
 	}
 
-	oldInterface := m.defaultInterfaceName
-	oldIndex := m.defaultInterfaceIndex
-
-	m.defaultInterfaceName = link.Attrs().Name
-	m.defaultInterfaceIndex = link.Attrs().Index
+	oldInterface := m.defaultInterface.Load()
+	newInterface, err := m.interfaceFinder.ByIndex(link.Attrs().Index)
+	if err != nil {
+		return E.Cause(err, "find updated interface: ", link.Attrs().Name)
+	}
+	m.defaultInterface.Store(newInterface)
 
-	var event int
-	if oldInterface != m.defaultInterfaceName || oldIndex != m.defaultInterfaceIndex {
-		event |= EventInterfaceUpdate
+	if oldInterface != nil && oldInterface.Equals(*newInterface) && oldVPNEnabled == m.androidVPNEnabled {
+		return nil
 	}
+	var flags int
 	if oldVPNEnabled != m.androidVPNEnabled {
-		event |= EventAndroidVPNUpdate
-	}
-	if event != 0 {
-		m.emit(event)
+		flags = FlagAndroidVPNUpdate
 	}
+	m.emit(newInterface, flags)
 
 	return nil
 }

monitor_darwin.go

@@ -7,6 +7,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/metacubex/sing-tun/control"
 	"github.com/sagernet/sing/common/buf"
 	E "github.com/sagernet/sing/common/exceptions"
 	"github.com/sagernet/sing/common/logger"
@@ -107,11 +108,11 @@ func (m *networkUpdateMonitor) Close() error {
 
 func (m *defaultInterfaceMonitor) checkUpdate() error {
 	var (
-		defaultInterface *net.Interface
+		defaultInterface *control.Interface
 		err              error
 	)
 	if m.underNetworkExtension {
-		defaultInterface, err = getDefaultInterfaceBySocket()
+		defaultInterface, err = m.getDefaultInterfaceBySocket()
 		if err != nil {
 			return err
 		}
@@ -144,7 +145,7 @@ func (m *defaultInterfaceMonitor) checkUpdate() error {
 			if ones != 0 {
 				continue
 			}
-			routeInterface, err := net.InterfaceByIndex(routeMessage.Index)
+			routeInterface, err := m.interfaceFinder.ByIndex(routeMessage.Index)
 			if err != nil {
 				return err
 			}
@@ -167,18 +168,20 @@ func (m *defaultInterfaceMonitor) checkUpdate() error {
 	if defaultInterface == nil {
 		return ErrNoRoute
 	}
-	oldInterface := m.defaultInterfaceName
-	oldIndex := m.defaultInterfaceIndex
-	m.defaultInterfaceIndex = defaultInterface.Index
-	m.defaultInterfaceName = defaultInterface.Name
-	if oldInterface == m.defaultInterfaceName && oldIndex == m.defaultInterfaceIndex {
+	oldInterface := m.defaultInterface.Load()
+	newInterface, err := m.interfaceFinder.ByIndex(defaultInterface.Index)
+	if err != nil {
+		return E.Cause(err, "find updated interface: ", defaultInterface.Name)
+	}
+	m.defaultInterface.Store(newInterface)
+	if oldInterface != nil && oldInterface.Equals(*newInterface) {
 		return nil
 	}
-	m.emit(EventInterfaceUpdate)
+	m.emit(newInterface, 0)
 	return nil
 }
 
-func getDefaultInterfaceBySocket() (*net.Interface, error) {
+func (m *defaultInterfaceMonitor) getDefaultInterfaceBySocket() (*control.Interface, error) {
 	socketFd, err := unix.Socket(unix.AF_INET, unix.SOCK_STREAM, 0)
 	if err != nil {
 		return nil, E.Cause(err, "create file descriptor")
@@ -221,24 +224,5 @@ func getDefaultInterfaceBySocket() (*net.Interface, error) {
 	case <-time.After(time.Second):
 		return nil, nil
 	}
-	interfaces, err := net.Interfaces()
-	if err != nil {
-		return nil, E.Cause(err, "net.Interfaces")
-	}
-	for _, netInterface := range interfaces {
-		interfaceAddrs, err := netInterface.Addrs()
-		if err != nil {
-			return nil, E.Cause(err, "net.Interfaces.Addrs")
-		}
-		for _, interfaceAddr := range interfaceAddrs {
-			ipNet, isIPNet := interfaceAddr.(*net.IPNet)
-			if !isIPNet {
-				continue
-			}
-			if ipNet.Contains(selectedAddr.AsSlice()) {
-				return &netInterface, nil
-			}
-		}
-	}
-	return nil, E.New("no interface found for address ", selectedAddr)
+	return m.interfaceFinder.ByAddr(selectedAddr)
 }