Merge remote-tracking branch 'origin/Alpha' into Alpha

adapter/inbound/socket.go

@@ -33,15 +33,10 @@ func NewInner(conn net.Conn, dst string, host string) *context.ConnContext {
 	metadata.Host = host
 	metadata.AddrType = C.AtypDomainName
 	metadata.Process = C.ClashName
-	if ip, port, err := parseAddr(dst); err == nil {
+	if h, port, err := net.SplitHostPort(dst); err == nil {
 		metadata.DstPort = port
 		if host == "" {
-			metadata.DstIP = ip
+			metadata.Host = h
-			if ip.Is4() {
-				metadata.AddrType = C.AtypIPv6
-			} else {
-				metadata.AddrType = C.AtypIPv4
-			}
 		}
 	}
 

adapter/provider/vehicle.go

@@ -2,7 +2,6 @@ package provider
 
 import (
 	"context"
-	"github.com/Dreamacro/clash/component/dialer"
 	"github.com/Dreamacro/clash/listener/inner"
 	"io"
 	"net"
@@ -86,10 +85,6 @@ func (h *HTTPVehicle) Read() ([]byte, error) {
 	client := http.Client{Transport: transport}
 	resp, err := client.Do(req)
 	if err != nil {
-		transport.DialContext = func(ctx context.Context, network, address string) (net.Conn, error) {
-			return dialer.DialContext(ctx, network, address)
-		}
-		resp, err = client.Do(req)
 		if err != nil {
 			return nil, err
 		}

config/config.go

@@ -151,7 +151,7 @@ type Config struct {
 	Users         []auth.AuthUser
 	Proxies       map[string]C.Proxy
 	Providers     map[string]providerTypes.ProxyProvider
-	RuleProviders map[string]*providerTypes.RuleProvider
+	RuleProviders map[string]providerTypes.RuleProvider
 	Sniffer       *Sniffer
 }
 
@@ -523,8 +523,8 @@ func parseProxies(cfg *RawConfig) (proxies map[string]C.Proxy, providersMap map[
 	return proxies, providersMap, nil
 }
 
-func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, map[string]*providerTypes.RuleProvider, error) {
+func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, map[string]providerTypes.RuleProvider, error) {
-	ruleProviders := map[string]*providerTypes.RuleProvider{}
+	ruleProviders := map[string]providerTypes.RuleProvider{}
 	log.Infoln("Geodata Loader mode: %s", geodata.LoaderName())
 	// parse rule provider
 	for name, mapping := range cfg.RuleProvider {
@@ -533,7 +533,7 @@ func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, map[strin
 			return nil, nil, err
 		}
 
-		ruleProviders[name] = &rp
+		ruleProviders[name] = rp
 		RP.SetRuleProvider(rp)
 	}
 

hub/executor/executor.go

@@ -82,8 +82,9 @@ func ApplyConfig(cfg *config.Config, force bool) {
 	updateTun(cfg.Tun, cfg.DNS)
 	updateExperimental(cfg)
 	updateHosts(cfg.Hosts)
-	loadProvider(cfg.RuleProviders, cfg.Providers)
+	loadProxyProvider(cfg.Providers)
 	updateProfile(cfg)
+	loadRuleProvider(cfg.RuleProviders)
 
 	log.SetLevel(cfg.General.LogLevel)
 }
@@ -181,39 +182,41 @@ func updateProxies(proxies map[string]C.Proxy, providers map[string]provider.Pro
 	tunnel.UpdateProxies(proxies, providers)
 }
 
-func updateRules(rules []C.Rule, ruleProviders map[string]*provider.RuleProvider) {
+func updateRules(rules []C.Rule, ruleProviders map[string]provider.RuleProvider) {
 	tunnel.UpdateRules(rules, ruleProviders)
 }
 
-func loadProvider(ruleProviders map[string]*provider.RuleProvider, proxyProviders map[string]provider.ProxyProvider) {
+func loadProvider(pv provider.Provider) {
-	load := func(pv provider.Provider) {
+	if pv.VehicleType() == provider.Compatible {
-		if pv.VehicleType() == provider.Compatible {
+		log.Infoln("Start initial compatible provider %s", pv.Name())
-			log.Infoln("Start initial compatible provider %s", pv.Name())
+	} else {
-		} else {
+		log.Infoln("Start initial provider %s", (pv).Name())
-			log.Infoln("Start initial provider %s", (pv).Name())
+	}
-		}
-
-		if err := (pv).Initial(); err != nil {
-			switch pv.Type() {
-			case provider.Proxy:
-				{
-					log.Warnln("initial proxy provider %s error: %v", (pv).Name(), err)
-				}
-			case provider.Rule:
-				{
-					log.Warnln("initial rule provider %s error: %v", (pv).Name(), err)
-				}
 
+	if err := (pv).Initial(); err != nil {
+		switch pv.Type() {
+		case provider.Proxy:
+			{
+				log.Warnln("initial proxy provider %s error: %v", (pv).Name(), err)
 			}
+		case provider.Rule:
+			{
+				log.Warnln("initial rule provider %s error: %v", (pv).Name(), err)
+			}
+
 		}
 	}
+}
 
-	for _, proxyProvider := range proxyProviders {
+func loadRuleProvider(ruleProviders map[string]provider.RuleProvider) {
-		load(proxyProvider)
-	}
-
 	for _, ruleProvider := range ruleProviders {
-		load(*ruleProvider)
+		loadProvider(ruleProvider)
+	}
+}
+
+func loadProxyProvider(ruleProviders map[string]provider.ProxyProvider) {
+	for _, ruleProvider := range ruleProviders {
+		loadProvider(ruleProvider)
 	}
 }
 

listener/tun/ipstack/system/mars/nat/nat.go

@@ -1,6 +1,7 @@
 package nat
 
 import (
+	log "github.com/sirupsen/logrus"
 	"io"
 	"net"
 	"net/netip"
@@ -43,6 +44,7 @@ func Start(device io.ReadWriter, gateway, portal, broadcast netip.Addr) (*TCP, *
 		for {
 			n, err := device.Read(buf)
 			if err != nil {
+				log.Warnln("system error:%s", err.Error())
 				continue
 			}
 

rule/provider/classical_strategy.go

@@ -32,6 +32,7 @@ func (c *classicalStrategy) ShouldResolveIP() bool {
 func (c *classicalStrategy) OnUpdate(rules []string) {
 	var classicalRules []C.Rule
 	shouldResolveIP := false
+	count := 0
 	for _, rawRule := range rules {
 		ruleType, rule, params := ruleParse(rawRule)
 		r, err := parseRule(ruleType, rule, "", params)
@@ -43,11 +44,12 @@ func (c *classicalStrategy) OnUpdate(rules []string) {
 			}
 
 			classicalRules = append(classicalRules, r)
-			c.count++
+			count++
 		}
 	}
 
 	c.rules = classicalRules
+	c.count = count
 }
 
 func NewClassicalStrategy() *classicalStrategy {

rule/provider/domain_strategy.go

@@ -27,16 +27,18 @@ func (d *domainStrategy) ShouldResolveIP() bool {
 
 func (d *domainStrategy) OnUpdate(rules []string) {
 	domainTrie := trie.New[bool]()
+	count := 0
 	for _, rule := range rules {
 		err := domainTrie.Insert(rule, true)
 		if err != nil {
 			log.Warnln("invalid domain:[%s]", rule)
 		} else {
-			d.count++
+			count++
 		}
 	}
 
 	d.domainRules = domainTrie
+	d.count = count
 }
 
 func ruleParse(ruleRaw string) (string, string, []string) {

rule/provider/fetcher.go

@@ -100,6 +100,7 @@ func (f *fetcher) Update() (interface{}, bool, error) {
 	hash := md5.Sum(buf)
 	if bytes.Equal(f.hash[:], hash[:]) {
 		f.updatedAt = &now
+		os.Chtimes(f.vehicle.Path(), now, now)
 		return nil, true, nil
 	}
 

rule/provider/ipcidr_strategy.go

@@ -26,16 +26,18 @@ func (i *ipcidrStrategy) ShouldResolveIP() bool {
 
 func (i *ipcidrStrategy) OnUpdate(rules []string) {
 	ipCidrTrie := trie.NewIpCidrTrie()
+	count := 0
 	for _, rule := range rules {
 		err := ipCidrTrie.AddIpCidrForString(rule)
 		if err != nil {
 			log.Warnln("invalid Ipcidr:[%s]", rule)
 		} else {
-			i.count++
+			count++
 		}
 	}
 
 	i.trie = ipCidrTrie
+	i.count = count
 	i.shouldResolveIP = i.count > 0
 }
 

tunnel/tunnel.go

@@ -30,7 +30,7 @@ var (
 	rules         []C.Rule
 	proxies       = make(map[string]C.Proxy)
 	providers     map[string]provider.ProxyProvider
-	ruleProviders map[string]*provider.RuleProvider
+	ruleProviders map[string]provider.RuleProvider
 	configMux     sync.RWMutex
 
 	// Outbound Rule
@@ -62,7 +62,7 @@ func Rules() []C.Rule {
 }
 
 // UpdateRules handle update rules
-func UpdateRules(newRules []C.Rule, rp map[string]*provider.RuleProvider) {
+func UpdateRules(newRules []C.Rule, rp map[string]provider.RuleProvider) {
 	configMux.Lock()
 	rules = newRules
 	ruleProviders = rp
@@ -80,7 +80,7 @@ func Providers() map[string]provider.ProxyProvider {
 }
 
 // RuleProviders return all loaded rule providers
-func RuleProviders() map[string]*provider.RuleProvider {
+func RuleProviders() map[string]provider.RuleProvider {
 	return ruleProviders
 }