chore: the resolve and findProcess behaviors of Logic and SubRules follow the order and needs of the internal rules

wwqgtxx · wwqgtxx · commit ae7967f66296 · 2025-06-10T20:11:50.000+08:00
diff --git a/constant/provider/interface.go b/constant/provider/interface.go
@@ -91,9 +91,7 @@ type RuleProvider interface {
 	Provider
 	Behavior() RuleBehavior
 	Count() int
-	Match(*constant.Metadata) bool
-	ShouldResolveIP() bool
-	ShouldFindProcess() bool
+	Match(metadata *constant.Metadata, helper constant.RuleMatchHelper) bool
 	Strategy() any
 }
 
diff --git a/constant/rule.go b/constant/rule.go
@@ -111,14 +111,17 @@ func (rt RuleType) String() string {
 
 type Rule interface {
 	RuleType() RuleType
-	Match(metadata *Metadata) (bool, string)
+	Match(metadata *Metadata, helper RuleMatchHelper) (bool, string)
 	Adapter() string
 	Payload() string
-	ShouldResolveIP() bool
-	ShouldFindProcess() bool
 	ProviderNames() []string
 }
 
+type RuleMatchHelper struct {
+	ResolveIP   func()
+	FindProcess func()
+}
+
 type RuleGroup interface {
 	Rule
 	GetRecodeSize() int
diff --git a/rules/common/base.go b/rules/common/base.go
@@ -21,14 +21,6 @@ var (
 type Base struct {
 }
 
-func (b *Base) ShouldFindProcess() bool {
-	return false
-}
-
-func (b *Base) ShouldResolveIP() bool {
-	return false
-}
-
 func (b *Base) ProviderNames() []string { return nil }
 
 func ParseParams(params []string) (isSrc bool, noResolve bool) {
diff --git a/rules/common/domain.go b/rules/common/domain.go
@@ -17,7 +17,7 @@ func (d *Domain) RuleType() C.RuleType {
 	return C.Domain
 }
 
-func (d *Domain) Match(metadata *C.Metadata) (bool, string) {
+func (d *Domain) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
 	return metadata.RuleHost() == d.domain, d.adapter
 }
 
diff --git a/rules/common/domain_keyword.go b/rules/common/domain_keyword.go
@@ -17,7 +17,7 @@ func (dk *DomainKeyword) RuleType() C.RuleType {
 	return C.DomainKeyword
 }
 
-func (dk *DomainKeyword) Match(metadata *C.Metadata) (bool, string) {
+func (dk *DomainKeyword) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
 	domain := metadata.RuleHost()
 	return strings.Contains(domain, dk.keyword), dk.adapter
 }
diff --git a/rules/common/domain_regex.go b/rules/common/domain_regex.go
@@ -16,7 +16,7 @@ func (dr *DomainRegex) RuleType() C.RuleType {
 	return C.DomainRegex
 }
 
-func (dr *DomainRegex) Match(metadata *C.Metadata) (bool, string) {
+func (dr *DomainRegex) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
 	domain := metadata.RuleHost()
 	match, _ := dr.regex.MatchString(domain)
 	return match, dr.adapter
diff --git a/rules/common/domain_suffix.go b/rules/common/domain_suffix.go
@@ -17,7 +17,7 @@ func (ds *DomainSuffix) RuleType() C.RuleType {
 	return C.DomainSuffix
 }
 
-func (ds *DomainSuffix) Match(metadata *C.Metadata) (bool, string) {
+func (ds *DomainSuffix) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
 	domain := metadata.RuleHost()
 	return strings.HasSuffix(domain, "."+ds.suffix) || domain == ds.suffix, ds.adapter
 }
diff --git a/rules/common/dscp.go b/rules/common/dscp.go
@@ -18,7 +18,7 @@ func (d *DSCP) RuleType() C.RuleType {
 	return C.DSCP
 }
 
-func (d *DSCP) Match(metadata *C.Metadata) (bool, string) {
+func (d *DSCP) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
 	return d.ranges.Check(metadata.DSCP), d.adapter
 }
 
diff --git a/rules/common/final.go b/rules/common/final.go
@@ -13,7 +13,7 @@ func (f *Match) RuleType() C.RuleType {
 	return C.MATCH
 }
 
-func (f *Match) Match(metadata *C.Metadata) (bool, string) {
+func (f *Match) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
 	return true, f.adapter
 }
 
diff --git a/rules/common/geoip.go b/rules/common/geoip.go
@@ -33,7 +33,11 @@ func (g *GEOIP) RuleType() C.RuleType {
 	return C.GEOIP
 }
 
-func (g *GEOIP) Match(metadata *C.Metadata) (bool, string) {
+func (g *GEOIP) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
+	if !g.noResolveIP && !g.isSourceIP && helper.ResolveIP != nil {
+		helper.ResolveIP()
+	}
+
 	ip := metadata.DstIP
 	if g.isSourceIP {
 		ip = metadata.SrcIP
@@ -161,10 +165,6 @@ func (g *GEOIP) Payload() string {
 	return g.country
 }
 
-func (g *GEOIP) ShouldResolveIP() bool {
-	return !g.noResolveIP
-}
-
 func (g *GEOIP) GetCountry() string {
 	return g.country
 }
diff --git a/rules/common/geosite.go b/rules/common/geosite.go
@@ -22,7 +22,7 @@ func (gs *GEOSITE) RuleType() C.RuleType {
 	return C.GEOSITE
 }
 
-func (gs *GEOSITE) Match(metadata *C.Metadata) (bool, string) {
+func (gs *GEOSITE) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
 	return gs.MatchDomain(metadata.RuleHost()), gs.adapter
 }
 
diff --git a/rules/common/in_name.go b/rules/common/in_name.go
@@ -13,7 +13,7 @@ type InName struct {
 	payload string
 }
 
-func (u *InName) Match(metadata *C.Metadata) (bool, string) {
+func (u *InName) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
 	for _, name := range u.names {
 		if metadata.InName == name {
 			return true, u.adapter
diff --git a/rules/common/in_type.go b/rules/common/in_type.go
@@ -13,7 +13,7 @@ type InType struct {
 	payload string
 }
 
-func (u *InType) Match(metadata *C.Metadata) (bool, string) {
+func (u *InType) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
 	for _, tp := range u.types {
 		if metadata.Type == tp {
 			return true, u.adapter
diff --git a/rules/common/in_user.go b/rules/common/in_user.go
@@ -13,7 +13,7 @@ type InUser struct {
 	payload string
 }
 
-func (u *InUser) Match(metadata *C.Metadata) (bool, string) {
+func (u *InUser) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
 	for _, user := range u.users {
 		if metadata.InUser == user {
 			return true, u.adapter
diff --git a/rules/common/ipasn.go b/rules/common/ipasn.go
@@ -15,7 +15,11 @@ type ASN struct {
 	isSourceIP  bool
 }
 
-func (a *ASN) Match(metadata *C.Metadata) (bool, string) {
+func (a *ASN) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
+	if !a.noResolveIP && !a.isSourceIP && helper.ResolveIP != nil {
+		helper.ResolveIP()
+	}
+
 	ip := metadata.DstIP
 	if a.isSourceIP {
 		ip = metadata.SrcIP
@@ -49,10 +53,6 @@ func (a *ASN) Payload() string {
 	return a.asn
 }
 
-func (a *ASN) ShouldResolveIP() bool {
-	return !a.noResolveIP
-}
-
 func (a *ASN) GetASN() string {
 	return a.asn
 }
diff --git a/rules/common/ipcidr.go b/rules/common/ipcidr.go
@@ -35,7 +35,11 @@ func (i *IPCIDR) RuleType() C.RuleType {
 	return C.IPCIDR
 }
 
-func (i *IPCIDR) Match(metadata *C.Metadata) (bool, string) {
+func (i *IPCIDR) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
+	if !i.noResolveIP && !i.isSourceIP && helper.ResolveIP != nil {
+		helper.ResolveIP()
+	}
+
 	ip := metadata.DstIP
 	if i.isSourceIP {
 		ip = metadata.SrcIP
@@ -51,10 +55,6 @@ func (i *IPCIDR) Payload() string {
 	return i.ipnet.String()
 }
 
-func (i *IPCIDR) ShouldResolveIP() bool {
-	return !i.noResolveIP
-}
-
 func NewIPCIDR(s string, adapter string, opts ...IPCIDROption) (*IPCIDR, error) {
 	ipnet, err := netip.ParsePrefix(s)
 	if err != nil {
diff --git a/rules/common/ipsuffix.go b/rules/common/ipsuffix.go
@@ -22,7 +22,11 @@ func (is *IPSuffix) RuleType() C.RuleType {
 	return C.IPSuffix
 }
 
-func (is *IPSuffix) Match(metadata *C.Metadata) (bool, string) {
+func (is *IPSuffix) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
+	if !is.noResolveIP && !is.isSourceIP && helper.ResolveIP != nil {
+		helper.ResolveIP()
+	}
+
 	ip := metadata.DstIP
 	if is.isSourceIP {
 		ip = metadata.SrcIP
@@ -57,10 +61,6 @@ func (is *IPSuffix) Payload() string {
 	return is.payload
 }
 
-func (is *IPSuffix) ShouldResolveIP() bool {
-	return !is.noResolveIP
-}
-
 func NewIPSuffix(payload, adapter string, isSrc, noResolveIP bool) (*IPSuffix, error) {
 	ipnet, err := netip.ParsePrefix(payload)
 	if err != nil {
diff --git a/rules/common/network_type.go b/rules/common/network_type.go
@@ -34,7 +34,7 @@ func (n *NetworkType) RuleType() C.RuleType {
 	return C.Network
 }
 
-func (n *NetworkType) Match(metadata *C.Metadata) (bool, string) {
+func (n *NetworkType) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
 	return n.network == metadata.NetWork, n.adapter
 }
 
diff --git a/rules/common/port.go b/rules/common/port.go
@@ -19,7 +19,7 @@ func (p *Port) RuleType() C.RuleType {
 	return p.ruleType
 }
 
-func (p *Port) Match(metadata *C.Metadata) (bool, string) {
+func (p *Port) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
 	targetPort := metadata.DstPort
 	switch p.ruleType {
 	case C.InPort:
diff --git a/rules/common/process.go b/rules/common/process.go
@@ -30,7 +30,10 @@ func (ps *Process) RuleType() C.RuleType {
 	return C.ProcessPath
 }
 
-func (ps *Process) Match(metadata *C.Metadata) (bool, string) {
+func (ps *Process) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
+	if helper.FindProcess != nil {
+		helper.FindProcess()
+	}
 	if ps.nameOnly {
 		if ps.regexp != nil {
 			match, _ := ps.regexp.MatchString(metadata.Process)
@@ -54,10 +57,6 @@ func (ps *Process) Payload() string {
 	return ps.process
 }
 
-func (ps *Process) ShouldFindProcess() bool {
-	return true
-}
-
 func NewProcess(process string, adapter string, nameOnly bool, regex bool) (*Process, error) {
 	var r *regexp2.Regexp
 	var err error
diff --git a/rules/common/uid.go b/rules/common/uid.go
@@ -41,7 +41,10 @@ func (u *Uid) RuleType() C.RuleType {
 	return C.Uid
 }
 
-func (u *Uid) Match(metadata *C.Metadata) (bool, string) {
+func (u *Uid) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
+	if helper.FindProcess != nil {
+		helper.FindProcess()
+	}
 	if metadata.Uid != 0 {
 		if u.uids.Check(metadata.Uid) {
 			return true, u.adapter
@@ -58,7 +61,3 @@ func (u *Uid) Adapter() string {
 func (u *Uid) Payload() string {
 	return u.oUid
 }
-
-func (u *Uid) ShouldFindProcess() bool {
-	return true
-}
diff --git a/rules/logic/logic.go b/rules/logic/logic.go
@@ -195,11 +195,11 @@ func (logic *Logic) RuleType() C.RuleType {
 	return logic.ruleType
 }
 
-func matchSubRules(metadata *C.Metadata, name string, subRules map[string][]C.Rule) (bool, string) {
+func matchSubRules(metadata *C.Metadata, name string, subRules map[string][]C.Rule, helper C.RuleMatchHelper) (bool, string) {
 	for _, rule := range subRules[name] {
-		if m, a := rule.Match(metadata); m {
+		if m, a := rule.Match(metadata, helper); m {
 			if rule.RuleType() == C.SubRules {
-				return matchSubRules(metadata, rule.Adapter(), subRules)
+				return matchSubRules(metadata, rule.Adapter(), subRules, helper)
 			} else {
 				return m, a
 			}
@@ -208,28 +208,28 @@ func matchSubRules(metadata *C.Metadata, name string, subRules map[string][]C.Ru
 	return false, ""
 }
 
-func (logic *Logic) Match(metadata *C.Metadata) (bool, string) {
+func (logic *Logic) Match(metadata *C.Metadata, helper C.RuleMatchHelper) (bool, string) {
 	switch logic.ruleType {
 	case C.SubRules:
-		if m, _ := logic.rules[0].Match(metadata); m {
-			return matchSubRules(metadata, logic.adapter, logic.subRules)
+		if m, _ := logic.rules[0].Match(metadata, helper); m {
+			return matchSubRules(metadata, logic.adapter, logic.subRules, helper)
 		}
 		return false, ""
 	case C.NOT:
-		if m, _ := logic.rules[0].Match(metadata); !m {
+		if m, _ := logic.rules[0].Match(metadata, helper); !m {
 			return true, logic.adapter
 		}
 		return false, ""
 	case C.OR:
 		for _, rule := range logic.rules {
-			if m, _ := rule.Match(metadata); m {
+			if m, _ := rule.Match(metadata, helper); m {
 				return true, logic.adapter
 			}
 		}
 		return false, ""
 	case C.AND:
 		for _, rule := range logic.rules {
-			if m, _ := rule.Match(metadata); !m {
+			if m, _ := rule.Match(metadata, helper); !m {
 				return false, logic.adapter
 			}
 		}
@@ -266,38 +266,6 @@ func (logic *Logic) Payload() string {
 	return logic.payload
 }
 
-func (logic *Logic) ShouldResolveIP() bool {
-	if logic.ruleType == C.SubRules {
-		for _, rule := range logic.subRules[logic.adapter] {
-			if rule.ShouldResolveIP() {
-				return true
-			}
-		}
-	}
-	for _, rule := range logic.rules {
-		if rule.ShouldResolveIP() {
-			return true
-		}
-	}
-	return false
-}
-
-func (logic *Logic) ShouldFindProcess() bool {
-	if logic.ruleType == C.SubRules {
-		for _, rule := range logic.subRules[logic.adapter] {
-			if rule.ShouldFindProcess() {
-				return true
-			}
-		}
-	}
-	for _, rule := range logic.rules {
-		if rule.ShouldFindProcess() {
-			return true
-		}
-	}
-	return false
-}
-
 func (logic *Logic) ProviderNames() (names []string) {
 	for _, rule := range logic.rules {
 		names = append(names, rule.ProviderNames()...)
diff --git a/rules/logic_test/logic_test.go b/rules/logic_test/logic_test.go
diff --git a/rules/provider/classical_strategy.go b/rules/provider/classical_strategy.go
diff --git a/rules/provider/domain_strategy.go b/rules/provider/domain_strategy.go
diff --git a/rules/provider/ipcidr_strategy.go b/rules/provider/ipcidr_strategy.go
diff --git a/rules/provider/provider.go b/rules/provider/provider.go
diff --git a/rules/provider/rule_set.go b/rules/provider/rule_set.go
diff --git a/tunnel/tunnel.go b/tunnel/tunnel.go

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ func (d *Domain) RuleType() C.RuleType {`
`17`	`17`	`return C.Domain`
`18`	`18`	`}`
`19`	`19`
`20`		`-func (d Domain) Match(metadata C.Metadata) (bool, string) {`
	`20`	`+func (d Domain) Match(metadata C.Metadata, helper C.RuleMatchHelper) (bool, string) {`
`21`	`21`	`return metadata.RuleHost() == d.domain, d.adapter`
`22`	`22`	`}`
`23`	`23`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ func (dk *DomainKeyword) RuleType() C.RuleType {`
`17`	`17`	`return C.DomainKeyword`
`18`	`18`	`}`
`19`	`19`
`20`		`-func (dk DomainKeyword) Match(metadata C.Metadata) (bool, string) {`
	`20`	`+func (dk DomainKeyword) Match(metadata C.Metadata, helper C.RuleMatchHelper) (bool, string) {`
`21`	`21`	`domain := metadata.RuleHost()`
`22`	`22`	`return strings.Contains(domain, dk.keyword), dk.adapter`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ func (dr *DomainRegex) RuleType() C.RuleType {`
`16`	`16`	`return C.DomainRegex`
`17`	`17`	`}`
`18`	`18`
`19`		`-func (dr DomainRegex) Match(metadata C.Metadata) (bool, string) {`
	`19`	`+func (dr DomainRegex) Match(metadata C.Metadata, helper C.RuleMatchHelper) (bool, string) {`
`20`	`20`	`domain := metadata.RuleHost()`
`21`	`21`	`match, _ := dr.regex.MatchString(domain)`
`22`	`22`	`return match, dr.adapter`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ func (ds *DomainSuffix) RuleType() C.RuleType {`
`17`	`17`	`return C.DomainSuffix`
`18`	`18`	`}`
`19`	`19`
`20`		`-func (ds DomainSuffix) Match(metadata C.Metadata) (bool, string) {`
	`20`	`+func (ds DomainSuffix) Match(metadata C.Metadata, helper C.RuleMatchHelper) (bool, string) {`
`21`	`21`	`domain := metadata.RuleHost()`
`22`	`22`	`return strings.HasSuffix(domain, "."+ds.suffix) \|\| domain == ds.suffix, ds.adapter`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ func (d *DSCP) RuleType() C.RuleType {`
`18`	`18`	`return C.DSCP`
`19`	`19`	`}`
`20`	`20`
`21`		`-func (d DSCP) Match(metadata C.Metadata) (bool, string) {`
	`21`	`+func (d DSCP) Match(metadata C.Metadata, helper C.RuleMatchHelper) (bool, string) {`
`22`	`22`	`return d.ranges.Check(metadata.DSCP), d.adapter`
`23`	`23`	`}`
`24`	`24`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ func (f *Match) RuleType() C.RuleType {`
`13`	`13`	`return C.MATCH`
`14`	`14`	`}`
`15`	`15`
`16`		`-func (f Match) Match(metadata C.Metadata) (bool, string) {`
	`16`	`+func (f Match) Match(metadata C.Metadata, helper C.RuleMatchHelper) (bool, string) {`
`17`	`17`	`return true, f.adapter`
`18`	`18`	`}`
`19`	`19`