chore: cleanup the patch code

dns/dhcp.go

@@ -1,5 +1,3 @@
-//go:build !(android && cmfa)
-
 package dns
 
 import (

dns/patch_android.go

@@ -3,53 +3,16 @@
 package dns
 
 import (
-	"context"
-
-	D "github.com/miekg/dns"
-
-	"github.com/metacubex/mihomo/common/lru"
-	"github.com/metacubex/mihomo/component/dhcp"
 	"github.com/metacubex/mihomo/component/resolver"
 )
 
 const SystemDNSPlaceholder = "system"
 
-var systemResolver *Resolver
-var isolateHandler handler
-
-var _ dnsClient = (*dhcpClient)(nil)
-
-type dhcpClient struct {
-	enable bool
-}
-
-func (d *dhcpClient) Address() string {
-	return SystemDNSPlaceholder
-}
-
-func (d *dhcpClient) Exchange(m *D.Msg) (msg *D.Msg, err error) {
-	return d.ExchangeContext(context.Background(), m)
-}
-
-func (d *dhcpClient) ExchangeContext(ctx context.Context, m *D.Msg) (msg *D.Msg, err error) {
-	if s := systemResolver; s != nil {
-		return s.ExchangeContext(ctx, m)
-	}
-
-	return nil, dhcp.ErrNotFound
-}
-
-func ServeDNSWithDefaultServer(msg *D.Msg) (*D.Msg, error) {
-	if h := isolateHandler; h != nil {
-		return handlerWithContext(context.Background(), h, msg)
-	}
-
-	return nil, D.ErrTime
-}
+var systemResolver []dnsClient
 
 func FlushCacheWithDefaultResolver() {
 	if r := resolver.DefaultResolver; r != nil {
-		r.(*Resolver).cache = lru.New(lru.WithSize[string, *D.Msg](4096), lru.WithStale[string, *D.Msg](true))
+		r.ClearCache()
 	}
 }
 
@@ -63,19 +26,9 @@ func UpdateSystemDNS(addr []string) {
 		ns = append(ns, NameServer{Addr: d})
 	}
 
-	systemResolver = NewResolver(Config{Main: ns})
+	systemResolver = transform(ns, nil)
 }
 
-func UpdateIsolateHandler(resolver *Resolver, mapper *ResolverEnhancer) {
-	if resolver == nil {
-		isolateHandler = nil
-
-		return
-	}
-
-	isolateHandler = NewHandler(resolver, mapper)
-}
-
-func newDHCPClient(ifaceName string) *dhcpClient {
-	return &dhcpClient{enable: ifaceName == SystemDNSPlaceholder}
+func (c *systemClient) getDnsClients() ([]dnsClient, error) {
+	return systemResolver, nil
 }

dns/patch_common.go

@@ -1,6 +0,0 @@
-//go:build !(android && cmfa)
-
-package dns
-
-func UpdateIsolateHandler(resolver *Resolver, mapper *ResolverEnhancer) {
-}

dns/resolver.go

@@ -29,6 +29,7 @@ type dnsClient interface {
 type dnsCache interface {
 	GetWithExpire(key string) (*D.Msg, time.Time, bool)
 	SetWithExpire(key string, value *D.Msg, expire time.Time)
+	Clear()
 }
 
 type result struct {
@@ -369,6 +370,12 @@ func (r *Resolver) Invalid() bool {
 	return len(r.main) > 0
 }
 
+func (r *Resolver) ClearCache() {
+	if r != nil && r.cache != nil {
+		r.cache.Clear()
+	}
+}
+
 type NameServer struct {
 	Net          string
 	Addr         string

dns/server.go

@@ -6,7 +6,6 @@ import (
 	"net"
 
 	"github.com/metacubex/mihomo/common/sockopt"
-	"github.com/metacubex/mihomo/constant/features"
 	"github.com/metacubex/mihomo/context"
 	"github.com/metacubex/mihomo/log"
 
@@ -50,10 +49,6 @@ func (s *Server) SetHandler(handler handler) {
 }
 
 func ReCreateServer(addr string, resolver *Resolver, mapper *ResolverEnhancer) {
-	if features.CMFA {
-		UpdateIsolateHandler(resolver, mapper)
-	}
-
 	if addr == address && resolver != nil {
 		handler := NewHandler(resolver, mapper)
 		server.SetHandler(handler)

dns/system.go

@@ -3,16 +3,11 @@ package dns
 import (
 	"context"
 	"fmt"
-	"net"
 	"strings"
 	"sync"
 	"time"
 
-	"github.com/metacubex/mihomo/component/resolver"
-	"github.com/metacubex/mihomo/log"
-
 	D "github.com/miekg/dns"
-	"golang.org/x/exp/slices"
 )
 
 const (
@@ -31,64 +26,6 @@ type systemClient struct {
 	lastFlush  time.Time
 }
 
-func (c *systemClient) getDnsClients() ([]dnsClient, error) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	var err error
-	if time.Since(c.lastFlush) > SystemDnsFlushTime {
-		var nameservers []string
-		if nameservers, err = dnsReadConfig(); err == nil {
-			log.Debugln("[DNS] system dns update to %s", nameservers)
-			for _, addr := range nameservers {
-				if resolver.IsSystemDnsBlacklisted(addr) {
-					continue
-				}
-				if _, ok := c.dnsClients[addr]; !ok {
-					clients := transform(
-						[]NameServer{{
-							Addr: net.JoinHostPort(addr, "53"),
-							Net:  "udp",
-						}},
-						nil,
-					)
-					if len(clients) > 0 {
-						c.dnsClients[addr] = &systemDnsClient{
-							disableTimes: 0,
-							dnsClient:    clients[0],
-						}
-					}
-				}
-			}
-			available := 0
-			for nameserver, sdc := range c.dnsClients {
-				if slices.Contains(nameservers, nameserver) {
-					sdc.disableTimes = 0 // enable
-					available++
-				} else {
-					if sdc.disableTimes > SystemDnsDeleteTimes {
-						delete(c.dnsClients, nameserver) // drop too old dnsClient
-					} else {
-						sdc.disableTimes++
-					}
-				}
-			}
-			if available > 0 {
-				c.lastFlush = time.Now()
-			}
-		}
-	}
-	dnsClients := make([]dnsClient, 0, len(c.dnsClients))
-	for _, sdc := range c.dnsClients {
-		if sdc.disableTimes == 0 {
-			dnsClients = append(dnsClients, sdc.dnsClient)
-		}
-	}
-	if len(dnsClients) > 0 {
-		return dnsClients, nil
-	}
-	return nil, err
-}
-
 func (c *systemClient) ExchangeContext(ctx context.Context, m *D.Msg) (msg *D.Msg, err error) {
 	dnsClients, err := c.getDnsClients()
 	if err != nil {

dns/system_common.go

@@ -0,0 +1,71 @@
+//go:build !(android && cmfa)
+
+package dns
+
+import (
+	"net"
+	"time"
+
+	"github.com/metacubex/mihomo/component/resolver"
+	"github.com/metacubex/mihomo/log"
+
+	"golang.org/x/exp/slices"
+)
+
+func (c *systemClient) getDnsClients() ([]dnsClient, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	var err error
+	if time.Since(c.lastFlush) > SystemDnsFlushTime {
+		var nameservers []string
+		if nameservers, err = dnsReadConfig(); err == nil {
+			log.Debugln("[DNS] system dns update to %s", nameservers)
+			for _, addr := range nameservers {
+				if resolver.IsSystemDnsBlacklisted(addr) {
+					continue
+				}
+				if _, ok := c.dnsClients[addr]; !ok {
+					clients := transform(
+						[]NameServer{{
+							Addr: net.JoinHostPort(addr, "53"),
+							Net:  "udp",
+						}},
+						nil,
+					)
+					if len(clients) > 0 {
+						c.dnsClients[addr] = &systemDnsClient{
+							disableTimes: 0,
+							dnsClient:    clients[0],
+						}
+					}
+				}
+			}
+			available := 0
+			for nameserver, sdc := range c.dnsClients {
+				if slices.Contains(nameservers, nameserver) {
+					sdc.disableTimes = 0 // enable
+					available++
+				} else {
+					if sdc.disableTimes > SystemDnsDeleteTimes {
+						delete(c.dnsClients, nameserver) // drop too old dnsClient
+					} else {
+						sdc.disableTimes++
+					}
+				}
+			}
+			if available > 0 {
+				c.lastFlush = time.Now()
+			}
+		}
+	}
+	dnsClients := make([]dnsClient, 0, len(c.dnsClients))
+	for _, sdc := range c.dnsClients {
+		if sdc.disableTimes == 0 {
+			dnsClients = append(dnsClients, sdc.dnsClient)
+		}
+	}
+	if len(dnsClients) > 0 {
+		return dnsClients, nil
+	}
+	return nil, err
+}

dns/util.go

@@ -99,6 +99,10 @@ func transform(servers []NameServer, resolver *Resolver) []dnsClient {
 			ret = append(ret, newDoHClient(s.Addr, resolver, s.PreferH3, s.Params, s.ProxyAdapter, s.ProxyName))
 			continue
 		case "dhcp":
+			if s.Addr == "system" { // Compatible with old writing
+				ret = append(ret, newSystemClient())
+				continue
+			}
 			ret = append(ret, newDHCPClient(s.Addr))
 			continue
 		case "system":