Android: patch

adapter/inbound/http.go

@@ -12,6 +12,8 @@ func NewHTTP(target socks5.Addr, srcConn net.Conn, conn net.Conn, additions ...A
 	metadata := parseSocksAddr(target)
 	metadata.NetWork = C.TCP
 	metadata.Type = C.HTTP
+	metadata.RawSrcAddr = srcConn.RemoteAddr()
+	metadata.RawDstAddr = srcConn.LocalAddr()
 	ApplyAdditions(metadata, WithSrcAddr(srcConn.RemoteAddr()), WithInAddr(conn.LocalAddr()))
 	ApplyAdditions(metadata, additions...)
 	return conn, metadata

adapter/inbound/packet.go

@@ -10,6 +10,8 @@ func NewPacket(target socks5.Addr, packet C.UDPPacket, source C.Type, additions
 	metadata := parseSocksAddr(target)
 	metadata.NetWork = C.UDP
 	metadata.Type = source
+	metadata.RawSrcAddr = packet.LocalAddr()
+	metadata.RawDstAddr = metadata.UDPAddr()
 	ApplyAdditions(metadata, WithSrcAddr(packet.LocalAddr()))
 	if p, ok := packet.(C.UDPPacketInAddr); ok {
 		ApplyAdditions(metadata, WithInAddr(p.InAddr()))

adapter/outboundgroup/patch.go

@@ -0,0 +1,62 @@
+package outboundgroup
+
+import (
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/constant/provider"
+)
+
+type ProxyGroup interface {
+	C.ProxyAdapter
+
+	Providers() []provider.ProxyProvider
+	Proxies() []C.Proxy
+	Now() string
+}
+
+func (f *Fallback) Providers() []provider.ProxyProvider {
+	return f.providers
+}
+
+func (lb *LoadBalance) Providers() []provider.ProxyProvider {
+	return lb.providers
+}
+
+func (f *Fallback) Proxies() []C.Proxy {
+	return f.GetProxies(false)
+}
+
+func (lb *LoadBalance) Proxies() []C.Proxy {
+	return lb.GetProxies(false)
+}
+
+func (lb *LoadBalance) Now() string {
+	return ""
+}
+
+func (r *Relay) Providers() []provider.ProxyProvider {
+	return r.providers
+}
+
+func (r *Relay) Proxies() []C.Proxy {
+	return r.GetProxies(false)
+}
+
+func (r *Relay) Now() string {
+	return ""
+}
+
+func (s *Selector) Providers() []provider.ProxyProvider {
+	return s.providers
+}
+
+func (s *Selector) Proxies() []C.Proxy {
+	return s.GetProxies(false)
+}
+
+func (u *URLTest) Providers() []provider.ProxyProvider {
+	return u.providers
+}
+
+func (u *URLTest) Proxies() []C.Proxy {
+	return u.GetProxies(false)
+}

adapter/provider/healthcheck.go

@@ -18,6 +18,7 @@ import (
 
 const (
 	defaultURLTestTimeout = time.Second * 5
+	defaultURLTestURL     = "https://www.gstatic.com/generate_204"
 )
 
 type HealthCheckOption struct {
@@ -148,6 +149,11 @@ func (hc *HealthCheck) stop() {
 }
 
 func (hc *HealthCheck) check() {
+
+	if len(hc.proxies) == 0 {
+		return
+	}
+
 	_, _, _ = hc.singleDo.Do(func() (struct{}, error) {
 		id := utils.NewUUIDV4().String()
 		log.Debugln("Start New Health Checking {%s}", id)
@@ -223,6 +229,7 @@ func NewHealthCheck(proxies []C.Proxy, url string, interval uint, lazy bool, exp
 	if len(url) == 0 {
 		interval = 0
 		expectedStatus = nil
+		url = defaultURLTestURL
 	}
 
 	return &HealthCheck{

adapter/provider/parser.go

@@ -68,9 +68,6 @@ func ParseProxyProvider(name string, mapping map[string]any) (types.ProxyProvide
 	case "http":
 		if schema.Path != "" {
 			path := C.Path.Resolve(schema.Path)
-			if !C.Path.IsSafePath(path) {
-				return nil, fmt.Errorf("%w: %s", errSubPath, path)
-			}
 			vehicle = resource.NewHTTPVehicle(schema.URL, path)
 		} else {
 			path := C.Path.GetPathByHash("proxies", schema.URL)

adapter/provider/patch.go

@@ -0,0 +1,34 @@
+package provider
+
+import (
+	"time"
+)
+
+var (
+	suspended bool
+)
+
+type UpdatableProvider interface {
+	UpdatedAt() time.Time
+}
+
+func (pp *proxySetProvider) UpdatedAt() time.Time {
+	return pp.Fetcher.UpdatedAt
+}
+
+func (pp *proxySetProvider) Close() error {
+	pp.healthCheck.close()
+	pp.Fetcher.Destroy()
+
+	return nil
+}
+
+func (cp *compatibleProvider) Close() error {
+	cp.healthCheck.close()
+
+	return nil
+}
+
+func Suspend(s bool) {
+	suspended = s
+}

component/dialer/dialer.go

@@ -70,6 +70,9 @@ func DialContext(ctx context.Context, network, address string, options ...Option
 }
 
 func ListenPacket(ctx context.Context, network, address string, options ...Option) (net.PacketConn, error) {
+	if DefaultSocketHook != nil {
+		return listenPacketHooked(ctx, network, address)
+	}
 	cfg := applyOptions(options...)
 
 	lc := &net.ListenConfig{}
@@ -114,6 +117,9 @@ func GetTcpConcurrent() bool {
 }
 
 func dialContext(ctx context.Context, network string, destination netip.Addr, port string, opt *option) (net.Conn, error) {
+	if DefaultSocketHook != nil {
+		return dialContextHooked(ctx, network, destination, port)
+	}
 	address := net.JoinHostPort(destination.String(), port)
 
 	netDialer := opt.netDialer

component/dialer/patch.go

@@ -0,0 +1,37 @@
+package dialer
+
+import (
+	"context"
+	"net"
+	"net/netip"
+	"syscall"
+)
+
+type SocketControl func(network, address string, conn syscall.RawConn) error
+
+var DefaultSocketHook SocketControl
+
+func dialContextHooked(ctx context.Context, network string, destination netip.Addr, port string) (net.Conn, error) {
+	dialer := &net.Dialer{
+		Control: DefaultSocketHook,
+	}
+
+	conn, err := dialer.DialContext(ctx, network, net.JoinHostPort(destination.String(), port))
+	if err != nil {
+		return nil, err
+	}
+
+	if t, ok := conn.(*net.TCPConn); ok {
+		t.SetKeepAlive(false)
+	}
+
+	return conn, nil
+}
+
+func listenPacketHooked(ctx context.Context, network, address string) (net.PacketConn, error) {
+	lc := &net.ListenConfig{
+		Control: DefaultSocketHook,
+	}
+
+	return lc.ListenPacket(ctx, network, address)
+}

component/mmdb/patch.go

@@ -0,0 +1,16 @@
+package mmdb
+
+import "github.com/oschwald/maxminddb-golang"
+
+func InstallOverride(override *maxminddb.Reader) {
+	newReader := Reader{Reader: override}
+	switch override.Metadata.DatabaseType {
+	case "sing-geoip":
+		reader.databaseType = typeSing
+	case "Meta-geoip0":
+		reader.databaseType = typeMetaV0
+	default:
+		reader.databaseType = typeMaxmind
+	}
+	reader = newReader
+}

component/process/patch.go

@@ -0,0 +1,14 @@
+package process
+
+import "github.com/Dreamacro/clash/constant"
+
+type PackageNameResolver func(metadata *constant.Metadata) (string, error)
+
+var DefaultPackageNameResolver PackageNameResolver
+
+func FindPackageName(metadata *constant.Metadata) (string, error) {
+	if resolver := DefaultPackageNameResolver; resolver != nil {
+		return resolver(metadata)
+	}
+	return "", ErrPlatformNotSupport
+}

component/resource/fetcher.go

@@ -13,6 +13,10 @@ import (
 	"github.com/samber/lo"
 )
 
+const (
+	minInterval = time.Minute * 5
+)
+
 var (
 	fileMode os.FileMode = 0o666
 	dirMode  os.FileMode = 0o755
@@ -24,8 +28,7 @@ type Fetcher[V any] struct {
 	resourceType string
 	name         string
 	vehicle      types.Vehicle
-	UpdatedAt    *time.Time
+	UpdatedAt    time.Time
-	ticker       *time.Ticker
 	done         chan struct{}
 	hash         [16]byte
 	parser       Parser[V]
@@ -56,7 +59,7 @@ func (f *Fetcher[V]) Initial() (V, error) {
 	if stat, fErr := os.Stat(f.vehicle.Path()); fErr == nil {
 		buf, err = os.ReadFile(f.vehicle.Path())
 		modTime := stat.ModTime()
-		f.UpdatedAt = &modTime
+		f.UpdatedAt = modTime
 		isLocal = true
 		if f.interval != 0 && modTime.Add(f.interval).Before(time.Now()) {
 			log.Warnln("[Provider] %s not updated for a long time, force refresh", f.Name())
@@ -64,6 +67,7 @@ func (f *Fetcher[V]) Initial() (V, error) {
 		}
 	} else {
 		buf, err = f.vehicle.Read()
+		f.UpdatedAt = time.Now()
 	}
 
 	if err != nil {
@@ -113,7 +117,7 @@ func (f *Fetcher[V]) Initial() (V, error) {
 	f.hash = md5.Sum(buf)
 
 	// pull contents automatically
-	if f.ticker != nil {
+	if f.interval > 0 {
 		go f.pullLoop()
 	}
 
@@ -129,7 +133,7 @@ func (f *Fetcher[V]) Update() (V, bool, error) {
 	now := time.Now()
 	hash := md5.Sum(buf)
 	if bytes.Equal(f.hash[:], hash[:]) {
-		f.UpdatedAt = &now
+		f.UpdatedAt = now
 		_ = os.Chtimes(f.vehicle.Path(), now, now)
 		return lo.Empty[V](), true, nil
 	}
@@ -145,23 +149,31 @@ func (f *Fetcher[V]) Update() (V, bool, error) {
 		}
 	}
 
-	f.UpdatedAt = &now
+	f.UpdatedAt = now
 	f.hash = hash
 
 	return contents, false, nil
 }
 
 func (f *Fetcher[V]) Destroy() error {
-	if f.ticker != nil {
+	if f.interval > 0 {
 		f.done <- struct{}{}
 	}
 	return nil
 }
 
 func (f *Fetcher[V]) pullLoop() {
+	initialInterval := f.interval - time.Since(f.UpdatedAt)
+	if initialInterval < minInterval {
+		initialInterval = minInterval
+	}
+
+	timer := time.NewTimer(initialInterval)
+	defer timer.Stop()
 	for {
 		select {
-		case <-f.ticker.C:
+		case <-timer.C:
+			timer.Reset(f.interval)
 			elm, same, err := f.Update()
 			if err != nil {
 				log.Errorln("[Provider] %s pull error: %s", f.Name(), err.Error())
@@ -178,7 +190,6 @@ func (f *Fetcher[V]) pullLoop() {
 				f.OnUpdate(elm)
 			}
 		case <-f.done:
-			f.ticker.Stop()
 			return
 		}
 	}
@@ -197,17 +208,12 @@ func safeWrite(path string, buf []byte) error {
 }
 
 func NewFetcher[V any](name string, interval time.Duration, vehicle types.Vehicle, parser Parser[V], onUpdate func(V)) *Fetcher[V] {
-	var ticker *time.Ticker
-	if interval != 0 {
-		ticker = time.NewTicker(interval)
-	}
 
 	return &Fetcher[V]{
 		name:     name,
-		ticker:   ticker,
 		vehicle:  vehicle,
 		parser:   parser,
-		done:     make(chan struct{}, 1),
+		done:     make(chan struct{}, 8),
 		OnUpdate: onUpdate,
 		interval: interval,
 	}

config/config.go

@@ -58,7 +58,6 @@ type General struct {
 	TCPConcurrent           bool              `json:"tcp-concurrent"`
 	FindProcessMode         P.FindProcessMode `json:"find-process-mode"`
 	Sniffing                bool              `json:"sniffing"`
-	EBpf                    EBpf              `json:"-"`
 	GlobalClientFingerprint string            `json:"global-client-fingerprint"`
 	GlobalUA                string            `json:"global-ua"`
 }
@@ -193,29 +192,34 @@ type RawNTP struct {
 }
 
 type RawDNS struct {
-	Enable                bool              `yaml:"enable"`
+	Enable                bool              `yaml:"enable" json:"enable"`
-	PreferH3              bool              `yaml:"prefer-h3"`
+	PreferH3              bool              `yaml:"prefer-h3" json:"prefer-h3"`
-	IPv6                  bool              `yaml:"ipv6"`
+	IPv6                  bool              `yaml:"ipv6" json:"ipv6"`
-	IPv6Timeout           uint              `yaml:"ipv6-timeout"`
+	IPv6Timeout           uint              `yaml:"ipv6-timeout" json:"ipv6-timeout"`
-	UseHosts              bool              `yaml:"use-hosts"`
+	UseHosts              bool              `yaml:"use-hosts" json:"use-hosts"`
-	NameServer            []string          `yaml:"nameserver"`
+	NameServer            []string          `yaml:"nameserver" json:"nameserver"`
-	Fallback              []string          `yaml:"fallback"`
+	Fallback              []string          `yaml:"fallback" json:"fallback"`
-	FallbackFilter        RawFallbackFilter `yaml:"fallback-filter"`
+	FallbackFilter        RawFallbackFilter `yaml:"fallback-filter" json:"fallback-filter"`
-	Listen                string            `yaml:"listen"`
+	Listen                string            `yaml:"listen" json:"listen"`
-	EnhancedMode          C.DNSMode         `yaml:"enhanced-mode"`
+	EnhancedMode          C.DNSMode         `yaml:"enhanced-mode" json:"enhanced-mode"`
-	FakeIPRange           string            `yaml:"fake-ip-range"`
+	FakeIPRange           string            `yaml:"fake-ip-range" json:"fake-ip-range"`
-	FakeIPFilter          []string          `yaml:"fake-ip-filter"`
+	FakeIPFilter          []string          `yaml:"fake-ip-filter" json:"fake-ip-filter"`
-	DefaultNameserver     []string          `yaml:"default-nameserver"`
+	DefaultNameserver     []string          `yaml:"default-nameserver" json:"default-nameserver"`
-	NameServerPolicy      map[string]any    `yaml:"nameserver-policy"`
+	NameServerPolicy      map[string]any    `yaml:"nameserver-policy" json:"nameserver-policy"`
-	ProxyServerNameserver []string          `yaml:"proxy-server-nameserver"`
+	ProxyServerNameserver []string          `yaml:"proxy-server-nameserver" json:"proxy-server-nameserver"`
 }
 
 type RawFallbackFilter struct {
-	GeoIP     bool     `yaml:"geoip"`
+	GeoIP     bool     `yaml:"geoip" json:"geoip"`
-	GeoIPCode string   `yaml:"geoip-code"`
+	GeoIPCode string   `yaml:"geoip-code" json:"geoip-code"`
-	IPCIDR    []string `yaml:"ipcidr"`
+	IPCIDR    []string `yaml:"ipcidr" json:"ipcidr"`
-	Domain    []string `yaml:"domain"`
+	Domain    []string `yaml:"domain" json:"domain"`
-	GeoSite   []string `yaml:"geosite"`
+	GeoSite   []string `yaml:"geosite" json:"geosite"`
+}
+
+type RawClashForAndroid struct {
+	AppendSystemDNS   bool   `yaml:"append-system-dns" json:"append-system-dns"`
+	UiSubtitlePattern string `yaml:"ui-subtitle-pattern" json:"ui-subtitle-pattern"`
 }
 
 type RawTun struct {
@@ -263,23 +267,23 @@ type RawTuicServer struct {
 }
 
 type RawConfig struct {
-	Port                    int               `yaml:"port"`
+	Port                    int               `yaml:"port" json:"port"`
-	SocksPort               int               `yaml:"socks-port"`
+	SocksPort               int               `yaml:"socks-port" json:"socks-port"`
-	RedirPort               int               `yaml:"redir-port"`
+	RedirPort               int               `yaml:"redir-port" json:"redir-port"`
-	TProxyPort              int               `yaml:"tproxy-port"`
+	TProxyPort              int               `yaml:"tproxy-port" json:"tproxy-port"`
-	MixedPort               int               `yaml:"mixed-port"`
+	MixedPort               int               `yaml:"mixed-port" json:"mixed-port"`
 	ShadowSocksConfig       string            `yaml:"ss-config"`
 	VmessConfig             string            `yaml:"vmess-config"`
 	InboundTfo              bool              `yaml:"inbound-tfo"`
 	InboundMPTCP            bool              `yaml:"inbound-mptcp"`
-	Authentication          []string          `yaml:"authentication"`
+	Authentication          []string          `yaml:"authentication" json:"authentication"`
 	SkipAuthPrefixes        []netip.Prefix    `yaml:"skip-auth-prefixes"`
-	AllowLan                bool              `yaml:"allow-lan"`
+	AllowLan                bool              `yaml:"allow-lan" json:"allow-lan"`
-	BindAddress             string            `yaml:"bind-address"`
+	BindAddress             string            `yaml:"bind-address" json:"bind-address"`
-	Mode                    T.TunnelMode      `yaml:"mode"`
+	Mode                    T.TunnelMode      `yaml:"mode" json:"mode"`
-	UnifiedDelay            bool              `yaml:"unified-delay"`
+	UnifiedDelay            bool              `yaml:"unified-delay" json:"unified-delay"`
-	LogLevel                log.LogLevel      `yaml:"log-level"`
+	LogLevel                log.LogLevel      `yaml:"log-level" json:"log-level"`
-	IPv6                    bool              `yaml:"ipv6"`
+	IPv6                    bool              `yaml:"ipv6" json:"ipv6"`
 	ExternalController      string            `yaml:"external-controller"`
 	ExternalControllerTLS   string            `yaml:"external-controller-tls"`
 	ExternalUI              string            `yaml:"external-ui"`
@@ -289,20 +293,20 @@ type RawConfig struct {
 	Interface               string            `yaml:"interface-name"`
 	RoutingMark             int               `yaml:"routing-mark"`
 	Tunnels                 []LC.Tunnel       `yaml:"tunnels"`
-	GeodataMode             bool              `yaml:"geodata-mode"`
+	GeodataMode             bool              `yaml:"geodata-mode" json:"geodata-mode"`
-	GeodataLoader           string            `yaml:"geodata-loader"`
+	GeodataLoader           string            `yaml:"geodata-loader" json:"geodata-loader"`
 	TCPConcurrent           bool              `yaml:"tcp-concurrent" json:"tcp-concurrent"`
 	FindProcessMode         P.FindProcessMode `yaml:"find-process-mode" json:"find-process-mode"`
 	GlobalClientFingerprint string            `yaml:"global-client-fingerprint"`
 	GlobalUA                string            `yaml:"global-ua"`
 	KeepAliveInterval       int               `yaml:"keep-alive-interval"`
 
-	Sniffer       RawSniffer                `yaml:"sniffer"`
+	Sniffer       RawSniffer                `yaml:"sniffer" json:"sniffer"`
 	ProxyProvider map[string]map[string]any `yaml:"proxy-providers"`
 	RuleProvider  map[string]map[string]any `yaml:"rule-providers"`
-	Hosts         map[string]any            `yaml:"hosts"`
+	Hosts         map[string]any            `yaml:"hosts" json:"hosts"`
-	NTP           RawNTP                    `yaml:"ntp"`
+	NTP           RawNTP                    `yaml:"ntp" json:"ntp"`
-	DNS           RawDNS                    `yaml:"dns"`
+	DNS           RawDNS                    `yaml:"dns" json:"dns"`
 	Tun           RawTun                    `yaml:"tun"`
 	TuicServer    RawTuicServer             `yaml:"tuic-server"`
 	EBpf          EBpf                      `yaml:"ebpf"`
@@ -316,6 +320,8 @@ type RawConfig struct {
 	SubRules      map[string][]string       `yaml:"sub-rules"`
 	RawTLS        TLS                       `yaml:"tls"`
 	Listeners     []map[string]any          `yaml:"listeners"`
+
+	ClashForAndroid RawClashForAndroid `yaml:"clash-for-android" json:"clash-for-android"`
 }
 
 type GeoXUrl struct {
@@ -483,7 +489,6 @@ func ParseRawConfig(rawCfg *RawConfig) (*Config, error) {
 	startTime := time.Now()
 	config.Experimental = &rawCfg.Experimental
 	config.Profile = &rawCfg.Profile
-	config.IPTables = &rawCfg.IPTables
 	config.TLS = &rawCfg.RawTLS
 
 	general, err := parseGeneral(rawCfg)
@@ -544,11 +549,6 @@ func ParseRawConfig(rawCfg *RawConfig) (*Config, error) {
 	}
 	config.DNS = dnsCfg
 
-	err = parseTun(rawCfg.Tun, config.General)
-	if err != nil {
-		return nil, err
-	}
-
 	err = parseTuicServer(rawCfg.TuicServer, config.General)
 	if err != nil {
 		return nil, err
@@ -645,7 +645,6 @@ func parseGeneral(cfg *RawConfig) (*General, error) {
 		GeodataLoader:           cfg.GeodataLoader,
 		TCPConcurrent:           cfg.TCPConcurrent,
 		FindProcessMode:         cfg.FindProcessMode,
-		EBpf:                    cfg.EBpf,
 		GlobalClientFingerprint: cfg.GlobalClientFingerprint,
 		GlobalUA:                cfg.GlobalUA,
 	}, nil

constant/geodata.go

@@ -2,7 +2,7 @@ package constant
 
 var (
 	GeodataMode bool
-	GeoIpUrl    string
+	GeoIpUrl    = "https://fastly.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/geoip.dat"
-	MmdbUrl     string
+	MmdbUrl     = "https://fastly.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/geoip.metadb"
-	GeoSiteUrl  string
+	GeoSiteUrl  = "https://fastly.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/geosite.dat"
 )

constant/metadata.go

@@ -147,6 +147,9 @@ type Metadata struct {
 	SpecialProxy string     `json:"specialProxy"`
 	SpecialRules string     `json:"specialRules"`
 	RemoteDst    string     `json:"remoteDestination"`
+
+	RawSrcAddr net.Addr `json:"-"`
+	RawDstAddr net.Addr `json:"-"`
 	// Only domain rule
 	SniffHost string `json:"sniffHost"`
 }

dns/dhcp.go

@@ -1,3 +1,6 @@
+//go:build disabled
+// +build disabled
+
 package dns
 
 import (

dns/patch.go

@@ -0,0 +1,79 @@
+package dns
+
+import (
+	"context"
+
+	D "github.com/miekg/dns"
+
+	"github.com/Dreamacro/clash/common/cache"
+	"github.com/Dreamacro/clash/component/dhcp"
+	"github.com/Dreamacro/clash/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
+}
+
+func FlushCacheWithDefaultResolver() {
+	if r := resolver.DefaultResolver; r != nil {
+		r.(*Resolver).lruCache = cache.New[string, *D.Msg](cache.WithSize[string, *D.Msg](4096), cache.WithStale[string, *D.Msg](true))
+	}
+}
+
+func UpdateSystemDNS(addr []string) {
+	if len(addr) == 0 {
+		systemResolver = nil
+	}
+
+	ns := make([]NameServer, 0, len(addr))
+	for _, d := range addr {
+		ns = append(ns, NameServer{Addr: d})
+	}
+
+	systemResolver = NewResolver(Config{Main: ns})
+}
+
+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}
+}

dns/server.go

@@ -49,6 +49,7 @@ func (s *Server) SetHandler(handler handler) {
 }
 
 func ReCreateServer(addr string, resolver *Resolver, mapper *ResolverEnhancer) {
+	UpdateIsolateHandler(resolver, mapper)
 	if addr == address && resolver != nil {
 		handler := NewHandler(resolver, mapper)
 		server.SetHandler(handler)

hub/executor/executor.go

@@ -172,7 +172,7 @@ func updateListeners(general *config.General, listeners map[string]C.InboundList
 	listener.ReCreateHTTP(general.Port, tunnel.Tunnel)
 	listener.ReCreateSocks(general.SocksPort, tunnel.Tunnel)
 	listener.ReCreateRedir(general.RedirPort, tunnel.Tunnel)
-	listener.ReCreateAutoRedir(general.EBpf.AutoRedir, tunnel.Tunnel)
+	// listener.ReCreateAutoRedir(general.EBpf.AutoRedir, tunnel.Tunnel)
 	listener.ReCreateTProxy(general.TProxyPort, tunnel.Tunnel)
 	listener.ReCreateMixed(general.MixedPort, tunnel.Tunnel)
 	listener.ReCreateShadowSocks(general.ShadowSocksConfig, tunnel.Tunnel)

listener/http/patch.go

@@ -0,0 +1,7 @@
+package http
+
+import "net"
+
+func (l *Listener) Listener() net.Listener {
+	return l.listener
+}

listener/http/server.go

@@ -65,6 +65,9 @@ func NewWithAuthenticate(addr string, tunnel C.Tunnel, authenticate bool, additi
 				}
 				continue
 			}
+			if t, ok := conn.(*net.TCPConn); ok {
+				t.SetKeepAlive(false)
+			}
 			go HandleConn(conn, tunnel, c, additions...)
 		}
 	}()

listener/inner/tcp.go

@@ -27,6 +27,8 @@ func HandleTcp(address string) (conn net.Conn, err error) {
 	metadata.Type = C.INNER
 	metadata.DNSMode = C.DNSNormal
 	metadata.Process = C.ClashName
+	metadata.RawSrcAddr = conn1.RemoteAddr()
+	metadata.RawDstAddr = conn1.LocalAddr()
 	if h, port, err := net.SplitHostPort(address); err == nil {
 		if port, err := strconv.ParseUint(port, 10, 16); err == nil {
 			metadata.DstPort = uint16(port)

rules/provider/parse.go

@@ -62,15 +62,11 @@ func ParseRuleProvider(name string, mapping map[string]interface{}, parse func(t
 	case "http":
 		if schema.Path != "" {
 			path := C.Path.Resolve(schema.Path)
-			if !C.Path.IsSafePath(path) {
-				return nil, fmt.Errorf("%w: %s", errSubPath, path)
-			}
 			vehicle = resource.NewHTTPVehicle(schema.URL, path)
 		} else {
 			path := C.Path.GetPathByHash("rules", schema.URL)
 			vehicle = resource.NewHTTPVehicle(schema.URL, path)
 		}
-
 	default:
 		return nil, fmt.Errorf("unsupported vehicle type: %s", schema.Type)
 	}

rules/provider/patch.go

@@ -0,0 +1,25 @@
+package provider
+
+import "time"
+
+var (
+	suspended bool
+)
+
+type UpdatableProvider interface {
+	UpdatedAt() time.Time
+}
+
+func (f *ruleSetProvider) UpdatedAt() time.Time {
+	return f.Fetcher.UpdatedAt
+}
+
+func (rp *ruleSetProvider) Close() error {
+	rp.Fetcher.Destroy()
+
+	return nil
+}
+
+func Suspend(s bool) {
+	suspended = s
+}

tunnel/statistic/patch.go

@@ -0,0 +1,5 @@
+package statistic
+
+func (m *Manager) Total() (up, down int64) {
+	return m.uploadTotal.Load(), m.downloadTotal.Load()
+}

tunnel/tunnel.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"net"
 	"net/netip"
-	"path/filepath"
 	"runtime"
 	"sync"
 	"time"
@@ -47,6 +46,8 @@ var (
 	findProcessMode P.FindProcessMode
 
 	fakeIPRange netip.Prefix
+
+	procesCache string
 )
 
 type tunnel struct{}
@@ -593,8 +594,8 @@ func match(metadata *C.Metadata) (C.Proxy, C.Rule, error) {
 	configMux.RLock()
 	defer configMux.RUnlock()
 	var (
-		resolved             bool
+		resolved     bool
-		attemptProcessLookup = true
+		processFound bool
 	)
 
 	if node, ok := resolver.DefaultHosts.Search(metadata.Host, false); ok {
@@ -618,15 +619,17 @@ func match(metadata *C.Metadata) (C.Proxy, C.Rule, error) {
 			}()
 		}
 
-		if attemptProcessLookup && !findProcessMode.Off() && (findProcessMode.Always() || rule.ShouldFindProcess()) {
+		if !findProcessMode.Off() && !processFound && (findProcessMode.Always() || rule.ShouldFindProcess()) {
-			attemptProcessLookup = false
+			pkg, err := P.FindPackageName(metadata)
-			uid, path, err := P.FindProcessName(metadata.NetWork.String(), metadata.SrcIP, int(metadata.SrcPort))
 			if err != nil {
 				log.Debugln("[Process] find process %s: %v", metadata.String(), err)
 			} else {
-				metadata.Process = filepath.Base(path)
+				metadata.Process = pkg
-				metadata.ProcessPath = path
+				processFound = true
-				metadata.Uid = uid
+				if procesCache != metadata.Process {
+					log.Debugln("[Process] %s from process %s", metadata.String(), metadata.Process)
+				}
+				procesCache = metadata.Process
 			}
 		}