Allow nested logical rules

experimental/clashapi.go

@@ -5,6 +5,7 @@ import (
 	"os"
 
 	"github.com/sagernet/sing-box/adapter"
+	C "github.com/sagernet/sing-box/constant"
 	"github.com/sagernet/sing-box/log"
 	"github.com/sagernet/sing-box/option"
 	"github.com/sagernet/sing/common"
@@ -27,24 +28,35 @@ func NewClashServer(ctx context.Context, router adapter.Router, logFactory log.O
 
 func CalculateClashModeList(options option.Options) []string {
 	var clashMode []string
-	for _, dnsRule := range common.PtrValueOrDefault(options.DNS).Rules {
+	clashMode = append(clashMode, extraClashModeFromRule(common.PtrValueOrDefault(options.Route).Rules)...)
-		if dnsRule.DefaultOptions.ClashMode != "" && !common.Contains(clashMode, dnsRule.DefaultOptions.ClashMode) {
+	clashMode = append(clashMode, extraClashModeFromDNSRule(common.PtrValueOrDefault(options.DNS).Rules)...)
-			clashMode = append(clashMode, dnsRule.DefaultOptions.ClashMode)
+	clashMode = common.Uniq(clashMode)
-		}
+	return clashMode
-		for _, defaultRule := range dnsRule.LogicalOptions.Rules {
+}
-			if defaultRule.ClashMode != "" && !common.Contains(clashMode, defaultRule.ClashMode) {
+
-				clashMode = append(clashMode, defaultRule.ClashMode)
+func extraClashModeFromRule(rules []option.Rule) []string {
-			}
+	var clashMode []string
-		}
+	for _, rule := range rules {
-	}
+		switch rule.Type {
-	for _, rule := range common.PtrValueOrDefault(options.Route).Rules {
+		case C.RuleTypeDefault:
-		if rule.DefaultOptions.ClashMode != "" && !common.Contains(clashMode, rule.DefaultOptions.ClashMode) {
 			clashMode = append(clashMode, rule.DefaultOptions.ClashMode)
-		}
+		case C.RuleTypeLogical:
-		for _, defaultRule := range rule.LogicalOptions.Rules {
+			clashMode = append(clashMode, extraClashModeFromRule(rule.LogicalOptions.Rules)...)
-			if defaultRule.ClashMode != "" && !common.Contains(clashMode, defaultRule.ClashMode) {
+		}
-				clashMode = append(clashMode, defaultRule.ClashMode)
+	}
-			}
+	return clashMode
+}
+
+func extraClashModeFromDNSRule(rules []option.DNSRule) []string {
+	var clashMode []string
+	for _, rule := range rules {
+		switch rule.Type {
+		case C.RuleTypeDefault:
+			if rule.DefaultOptions.ClashMode != "" {
+				clashMode = append(clashMode, rule.DefaultOptions.ClashMode)
+			}
+		case C.RuleTypeLogical:
+			clashMode = append(clashMode, extraClashModeFromDNSRule(rule.LogicalOptions.Rules)...)
 		}
 	}
 	return clashMode

option/rule.go

@@ -53,6 +53,17 @@ func (r *Rule) UnmarshalJSON(bytes []byte) error {
 	return nil
 }
 
+func (r Rule) IsValid() bool {
+	switch r.Type {
+	case C.RuleTypeDefault:
+		return r.DefaultOptions.IsValid()
+	case C.RuleTypeLogical:
+		return r.LogicalOptions.IsValid()
+	default:
+		panic("unknown rule type: " + r.Type)
+	}
+}
+
 type DefaultRule struct {
 	Inbound         Listable[string] `json:"inbound,omitempty"`
 	IPVersion       int              `json:"ip_version,omitempty"`
@@ -93,11 +104,11 @@ func (r DefaultRule) IsValid() bool {
 
 type LogicalRule struct {
 	Mode     string `json:"mode"`
-	Rules    []DefaultRule `json:"rules,omitempty"`
+	Rules    []Rule `json:"rules,omitempty"`
 	Invert   bool   `json:"invert,omitempty"`
 	Outbound string `json:"outbound,omitempty"`
 }
 
 func (r LogicalRule) IsValid() bool {
-	return len(r.Rules) > 0 && common.All(r.Rules, DefaultRule.IsValid)
+	return len(r.Rules) > 0 && common.All(r.Rules, Rule.IsValid)
 }

option/rule_dns.go

@@ -53,6 +53,17 @@ func (r *DNSRule) UnmarshalJSON(bytes []byte) error {
 	return nil
 }
 
+func (r DNSRule) IsValid() bool {
+	switch r.Type {
+	case C.RuleTypeDefault:
+		return r.DefaultOptions.IsValid()
+	case C.RuleTypeLogical:
+		return r.LogicalOptions.IsValid()
+	default:
+		panic("unknown DNS rule type: " + r.Type)
+	}
+}
+
 type DefaultDNSRule struct {
 	Inbound         Listable[string]       `json:"inbound,omitempty"`
 	IPVersion       int                    `json:"ip_version,omitempty"`
@@ -97,7 +108,7 @@ func (r DefaultDNSRule) IsValid() bool {
 
 type LogicalDNSRule struct {
 	Mode         string    `json:"mode"`
-	Rules        []DefaultDNSRule `json:"rules,omitempty"`
+	Rules        []DNSRule `json:"rules,omitempty"`
 	Invert       bool      `json:"invert,omitempty"`
 	Server       string    `json:"server,omitempty"`
 	DisableCache bool      `json:"disable_cache,omitempty"`
@@ -105,5 +116,5 @@ type LogicalDNSRule struct {
 }
 
 func (r LogicalDNSRule) IsValid() bool {
-	return len(r.Rules) > 0 && common.All(r.Rules, DefaultDNSRule.IsValid)
+	return len(r.Rules) > 0 && common.All(r.Rules, DNSRule.IsValid)
 }

route/router_geo_resources.go

@@ -252,13 +252,11 @@ func hasRule(rules []option.Rule, cond func(rule option.DefaultRule) bool) bool
 				return true
 			}
 		case C.RuleTypeLogical:
-			for _, subRule := range rule.LogicalOptions.Rules {
+			if hasRule(rule.LogicalOptions.Rules, cond) {
-				if cond(subRule) {
 				return true
 			}
 		}
 	}
-	}
 	return false
 }
 
@@ -270,13 +268,11 @@ func hasDNSRule(rules []option.DNSRule, cond func(rule option.DefaultDNSRule) bo
 				return true
 			}
 		case C.RuleTypeLogical:
-			for _, subRule := range rule.LogicalOptions.Rules {
+			if hasDNSRule(rule.LogicalOptions.Rules, cond) {
-				if cond(subRule) {
 				return true
 			}
 		}
 	}
-	}
 	return false
 }
 

route/rule_default.go

@@ -220,7 +220,7 @@ func NewLogicalRule(router adapter.Router, logger log.ContextLogger, options opt
 		return nil, E.New("unknown logical mode: ", options.Mode)
 	}
 	for i, subRule := range options.Rules {
-		rule, err := NewDefaultRule(router, logger, subRule)
+		rule, err := NewRule(router, logger, subRule)
 		if err != nil {
 			return nil, E.Cause(err, "sub rule[", i, "]")
 		}

route/rule_dns.go

@@ -228,7 +228,7 @@ func NewLogicalDNSRule(router adapter.Router, logger log.ContextLogger, options
 		return nil, E.New("unknown logical mode: ", options.Mode)
 	}
 	for i, subRule := range options.Rules {
-		rule, err := NewDefaultDNSRule(router, logger, subRule)
+		rule, err := NewDNSRule(router, logger, subRule)
 		if err != nil {
 			return nil, E.Cause(err, "sub rule[", i, "]")
 		}