[test]

hub/executor/executor.go

@@ -2,7 +2,11 @@ package executor
 
 import (
 	"fmt"
+	"net"
 	"os"
+	"runtime"
+	"strconv"
+	"strings"
 	"sync"
 
 	"github.com/Dreamacro/clash/adapter"
@@ -13,6 +17,7 @@ import (
 	"github.com/Dreamacro/clash/component/profile"
 	"github.com/Dreamacro/clash/component/profile/cachefile"
 	"github.com/Dreamacro/clash/component/resolver"
+	S "github.com/Dreamacro/clash/component/script"
 	"github.com/Dreamacro/clash/component/trie"
 	"github.com/Dreamacro/clash/config"
 	C "github.com/Dreamacro/clash/constant"
@@ -20,6 +25,8 @@ import (
 	"github.com/Dreamacro/clash/dns"
 	P "github.com/Dreamacro/clash/listener"
 	authStore "github.com/Dreamacro/clash/listener/auth"
+	"github.com/Dreamacro/clash/listener/tproxy"
+	"github.com/Dreamacro/clash/listener/tun/dev"
 	"github.com/Dreamacro/clash/log"
 	"github.com/Dreamacro/clash/tunnel"
 )
@@ -70,10 +77,12 @@ func ApplyConfig(cfg *config.Config, force bool) {
 	updateUsers(cfg.Users)
 	updateProxies(cfg.Proxies, cfg.Providers)
 	updateRules(cfg.Rules)
+	updateRuleProviders(cfg.RuleProviders)
 	updateHosts(cfg.Hosts)
 	updateProfile(cfg)
+	updateIPTables(cfg.DNS, cfg.General)
+	updateDNS(cfg.DNS, cfg.General)
 	updateGeneral(cfg.General, force)
-	updateDNS(cfg.DNS)
 	updateExperimental(cfg)
 }
 
@@ -91,6 +100,7 @@ func GetGeneral() *config.General {
 			RedirPort:      ports.RedirPort,
 			TProxyPort:     ports.TProxyPort,
 			MixedPort:      ports.MixedPort,
+			Tun:            P.Tun(),
 			Authentication: authenticator,
 			AllowLan:       P.AllowLan(),
 			BindAddress:    P.BindAddress(),
@@ -105,9 +115,10 @@ func GetGeneral() *config.General {
 
 func updateExperimental(c *config.Config) {}
 
-func updateDNS(c *config.DNS) {
+func updateDNS(c *config.DNS, general *config.General) {
 	if !c.Enable {
 		resolver.DefaultResolver = nil
+		resolver.MainResolver = nil
 		resolver.DefaultHostMapper = nil
 		dns.ReCreateServer("", nil, nil)
 		return
@@ -125,12 +136,14 @@ func updateDNS(c *config.DNS) {
 			GeoIPCode: c.FallbackFilter.GeoIPCode,
 			IPCIDR:    c.FallbackFilter.IPCIDR,
 			Domain:    c.FallbackFilter.Domain,
+			GeoSite:   c.FallbackFilter.GeoSite,
 		},
 		Default: c.DefaultNameserver,
 		Policy:  c.NameServerPolicy,
 	}
 
 	r := dns.NewResolver(cfg)
+	mr := dns.NewMainResolver(r)
 	m := dns.NewEnhancer(cfg)
 
 	// reuse cache of old host mapper
@@ -139,7 +152,13 @@ func updateDNS(c *config.DNS) {
 	}
 
 	resolver.DefaultResolver = r
+	resolver.MainResolver = mr
 	resolver.DefaultHostMapper = m
+	if general.Tun.Enable && !strings.EqualFold(general.Tun.Stack, "gvisor") {
+		resolver.DefaultLocalServer = dns.NewLocalServer(r, m)
+	} else {
+		resolver.DefaultLocalServer = nil
+	}
 
 	if err := dns.ReCreateServer(c.Listen, r, m); err != nil {
 		log.Errorln("Start DNS server error: %s", err.Error())
@@ -163,16 +182,35 @@ func updateRules(rules []C.Rule) {
 	tunnel.UpdateRules(rules)
 }
 
+func updateRuleProviders(providers map[string]C.Rule) {
+	S.UpdateRuleProviders(providers)
+}
+
 func updateGeneral(general *config.General, force bool) {
-	log.SetLevel(general.LogLevel)
 	tunnel.SetMode(general.Mode)
 	resolver.DisableIPv6 = !general.IPv6
 
+	if (general.Tun.Enable || general.TProxyPort != 0) && general.Interface == "" {
+		autoDetectInterfaceName, err := dev.GetAutoDetectInterface()
+		if err == nil {
+			if autoDetectInterfaceName != "" && autoDetectInterfaceName != "<nil>" {
+				general.Interface = autoDetectInterfaceName
+			} else {
+				log.Debugln("Auto detect interface name is empty.")
+			}
+		} else {
+			log.Debugln("Can not find auto detect interface. %s", err.Error())
+		}
+	}
+
 	dialer.DefaultInterface.Store(general.Interface)
 
+	log.Infoln("Use interface name: %s", general.Interface)
+
 	iface.FlushCache()
 
 	if !force {
+		log.SetLevel(general.LogLevel)
 		return
 	}
 
@@ -204,6 +242,14 @@ func updateGeneral(general *config.General, force bool) {
 	if err := P.ReCreateMixed(general.MixedPort, tcpIn, udpIn); err != nil {
 		log.Errorln("Start Mixed(http and socks) server error: %s", err.Error())
 	}
+
+	if err := P.ReCreateTun(general.Tun, tcpIn, udpIn); err != nil {
+		log.Errorln("Start Tun interface error: %s", err.Error())
+		S.Py_Finalize()
+		os.Exit(2)
+	}
+
+	log.SetLevel(general.LogLevel)
 }
 
 func updateUsers(users []auth.AuthUser) {
@@ -248,3 +294,38 @@ func patchSelectGroup(proxies map[string]C.Proxy) {
 		selector.Set(selected)
 	}
 }
+
+func updateIPTables(dns *config.DNS, general *config.General) {
+	if runtime.GOOS != "linux" || dns.Listen == "" || general.TProxyPort == 0 || general.Tun.Enable {
+		return
+	}
+
+	_, dnsPortStr, err := net.SplitHostPort(dns.Listen)
+	if dnsPortStr == "0" || dnsPortStr == "" || err != nil {
+		return
+	}
+
+	dnsPort, err := strconv.Atoi(dnsPortStr)
+	if err != nil {
+		return
+	}
+
+	tproxy.CleanUpTProxyLinuxIPTables()
+
+	err = tproxy.SetTProxyLinuxIPTables(general.Interface, general.TProxyPort, dnsPort)
+
+	if err != nil {
+		log.Errorln("Can not setting iptables for TProxy on linux, %s", err.Error())
+		os.Exit(2)
+	}
+}
+
+func CleanUp() {
+	P.CleanUp()
+
+	if runtime.GOOS == "linux" {
+		tproxy.CleanUpTProxyLinuxIPTables()
+	}
+
+	S.Py_Finalize()
+}