世界
296 lines
13 KiB
Go
296 lines
13 KiB
Go
package option
|
|
|
|
import (
|
|
"context"
|
|
"reflect"
|
|
|
|
C "github.com/sagernet/sing-box/constant"
|
|
"github.com/sagernet/sing-box/schema"
|
|
"github.com/sagernet/sing/common"
|
|
E "github.com/sagernet/sing/common/exceptions"
|
|
"github.com/sagernet/sing/common/json"
|
|
"github.com/sagernet/sing/common/json/badjson"
|
|
"github.com/sagernet/sing/common/json/badoption"
|
|
)
|
|
|
|
type _Rule struct {
|
|
Type string `json:"type,omitempty" enum:"default,logical"`
|
|
DefaultOptions DefaultRule `json:"-"`
|
|
LogicalOptions LogicalRule `json:"-"`
|
|
}
|
|
|
|
type Rule _Rule
|
|
|
|
func (r Rule) MarshalJSON() ([]byte, error) {
|
|
var v any
|
|
switch r.Type {
|
|
case C.RuleTypeDefault:
|
|
r.Type = ""
|
|
v = r.DefaultOptions
|
|
case C.RuleTypeLogical:
|
|
v = r.LogicalOptions
|
|
default:
|
|
return nil, E.New("unknown rule type: " + r.Type)
|
|
}
|
|
return badjson.MarshallObjects((_Rule)(r), v)
|
|
}
|
|
|
|
func (r *Rule) UnmarshalJSONContext(ctx context.Context, bytes []byte) error {
|
|
err := json.UnmarshalContext(ctx, bytes, (*_Rule)(r))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
payload, err := rulePayloadWithoutType(ctx, bytes)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch r.Type {
|
|
case "", C.RuleTypeDefault:
|
|
r.Type = C.RuleTypeDefault
|
|
return unmarshalDefaultRuleContext(ctx, payload, &r.DefaultOptions)
|
|
case C.RuleTypeLogical:
|
|
return unmarshalLogicalRuleContext(ctx, payload, &r.LogicalOptions)
|
|
default:
|
|
return E.New("unknown rule type: " + r.Type)
|
|
}
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|
|
|
|
func (r Rule) DescribeSchema(builder schema.Builder) (*schema.Node, error) {
|
|
return builder.Define("Rule", func() (*schema.Node, error) {
|
|
actionRef, err := builder.Define("RuleAction", func() (*schema.Node, error) {
|
|
return routeActionUnion(builder)
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
nestedRef, err := builder.Define("NestedRule", func() (*schema.Node, error) {
|
|
return nestedRuleUnion(builder, reflect.TypeFor[RawDefaultRule](), "NestedRule")
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return ruleUnion(builder, reflect.TypeFor[RawDefaultRule](), nestedRef, actionRef)
|
|
})
|
|
}
|
|
|
|
// ruleUnion builds the top-level rule schema: match fields composed with rule
|
|
// actions via unevaluatedProperties, mirroring the badjson.UnmarshallExcluded
|
|
// composition in DefaultRule / LogicalRule.
|
|
func ruleUnion(builder schema.Builder, matchType reflect.Type, nestedRef *schema.Node, actionRef *schema.Node) (*schema.Node, error) {
|
|
defaultMatch := schema.LooseObject()
|
|
defaultMatch.Properties.Put("type", schema.StringEnum(C.RuleTypeDefault, ""))
|
|
err := builder.FlattenStruct(defaultMatch, matchType)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defaultVariant := &schema.Node{
|
|
Type: "object",
|
|
AllOf: []*schema.Node{defaultMatch, actionRef},
|
|
UnevaluatedProperties: false,
|
|
}
|
|
|
|
logicalMatch := schema.LooseObject()
|
|
logicalMatch.Properties.Put("type", schema.StringConst(C.RuleTypeLogical))
|
|
logicalProperties(logicalMatch, nestedRef)
|
|
logicalMatch.Required = []string{"type", "mode", "rules"}
|
|
logicalVariant := &schema.Node{
|
|
Type: "object",
|
|
AllOf: []*schema.Node{logicalMatch, actionRef},
|
|
UnevaluatedProperties: false,
|
|
}
|
|
|
|
return schema.OneOf(defaultVariant, logicalVariant), nil
|
|
}
|
|
|
|
// nestedRuleUnion builds a match-only rule schema: nested rules reject rule
|
|
// actions, and headless rules never carry them.
|
|
func nestedRuleUnion(builder schema.Builder, matchType reflect.Type, selfName string) (*schema.Node, error) {
|
|
defaultVariant := schema.StrictObject()
|
|
defaultVariant.Properties.Put("type", schema.StringEnum(C.RuleTypeDefault, ""))
|
|
err := builder.FlattenStruct(defaultVariant, matchType)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
logicalVariant := schema.StrictObject()
|
|
logicalVariant.Properties.Put("type", schema.StringConst(C.RuleTypeLogical))
|
|
logicalProperties(logicalVariant, schema.RefNode(selfName))
|
|
logicalVariant.Required = []string{"type", "mode", "rules"}
|
|
|
|
return schema.OneOf(defaultVariant, logicalVariant), nil
|
|
}
|
|
|
|
func logicalProperties(node *schema.Node, nestedRef *schema.Node) {
|
|
node.Properties.Put("mode", schema.StringEnum(C.LogicalTypeAnd, C.LogicalTypeOr))
|
|
node.Properties.Put("rules", &schema.Node{Type: "array", Items: nestedRef})
|
|
node.Properties.Put("invert", schema.BooleanNode())
|
|
}
|
|
|
|
type RawDefaultRule struct {
|
|
Inbound badoption.Listable[string] `json:"inbound,omitempty" reference:"inbound"`
|
|
IPVersion int `json:"ip_version,omitempty" enum:"4,6"`
|
|
Network badoption.Listable[string] `json:"network,omitempty" enum:"tcp,udp,icmp"`
|
|
AuthUser badoption.Listable[string] `json:"auth_user,omitempty"`
|
|
Protocol badoption.Listable[string] `json:"protocol,omitempty" enum:"tls,http,quic,dns,stun,bittorrent,dtls,ssh,rdp,ntp"`
|
|
Client badoption.Listable[string] `json:"client,omitempty"`
|
|
Domain badoption.Listable[string] `json:"domain,omitempty"`
|
|
DomainSuffix badoption.Listable[string] `json:"domain_suffix,omitempty"`
|
|
DomainKeyword badoption.Listable[string] `json:"domain_keyword,omitempty"`
|
|
DomainRegex badoption.Listable[string] `json:"domain_regex,omitempty"`
|
|
Geosite badoption.Listable[string] `json:"geosite,omitempty" schema:"omit"`
|
|
SourceGeoIP badoption.Listable[string] `json:"source_geoip,omitempty" schema:"omit"`
|
|
GeoIP badoption.Listable[string] `json:"geoip,omitempty" schema:"omit"`
|
|
SourceIPCIDR badoption.Listable[string] `json:"source_ip_cidr,omitempty"`
|
|
SourceIPIsPrivate bool `json:"source_ip_is_private,omitempty"`
|
|
IPCIDR badoption.Listable[string] `json:"ip_cidr,omitempty"`
|
|
IPIsPrivate bool `json:"ip_is_private,omitempty"`
|
|
SourcePort badoption.Listable[uint16] `json:"source_port,omitempty"`
|
|
SourcePortRange badoption.Listable[string] `json:"source_port_range,omitempty"`
|
|
Port badoption.Listable[uint16] `json:"port,omitempty"`
|
|
PortRange badoption.Listable[string] `json:"port_range,omitempty"`
|
|
ProcessName badoption.Listable[string] `json:"process_name,omitempty"`
|
|
ProcessPath badoption.Listable[string] `json:"process_path,omitempty"`
|
|
ProcessPathRegex badoption.Listable[string] `json:"process_path_regex,omitempty"`
|
|
PackageName badoption.Listable[string] `json:"package_name,omitempty"`
|
|
PackageNameRegex badoption.Listable[string] `json:"package_name_regex,omitempty"`
|
|
User badoption.Listable[string] `json:"user,omitempty"`
|
|
UserID badoption.Listable[int32] `json:"user_id,omitempty"`
|
|
ClashMode string `json:"clash_mode,omitempty"`
|
|
NetworkType badoption.Listable[InterfaceType] `json:"network_type,omitempty"`
|
|
NetworkIsExpensive bool `json:"network_is_expensive,omitempty"`
|
|
NetworkIsConstrained bool `json:"network_is_constrained,omitempty"`
|
|
WIFISSID badoption.Listable[string] `json:"wifi_ssid,omitempty"`
|
|
WIFIBSSID badoption.Listable[string] `json:"wifi_bssid,omitempty"`
|
|
InterfaceAddress *badjson.TypedMap[string, badoption.Listable[*badoption.Prefixable]] `json:"interface_address,omitempty"`
|
|
NetworkInterfaceAddress *badjson.TypedMap[InterfaceType, badoption.Listable[*badoption.Prefixable]] `json:"network_interface_address,omitempty"`
|
|
DefaultInterfaceAddress badoption.Listable[*badoption.Prefixable] `json:"default_interface_address,omitempty"`
|
|
SourceMACAddress badoption.Listable[string] `json:"source_mac_address,omitempty"`
|
|
SourceHostname badoption.Listable[string] `json:"source_hostname,omitempty"`
|
|
PreferredBy badoption.Listable[string] `json:"preferred_by,omitempty"`
|
|
RuleSet badoption.Listable[string] `json:"rule_set,omitempty" reference:"rule_set"`
|
|
RuleSetIPCIDRMatchSource bool `json:"rule_set_ip_cidr_match_source,omitempty"`
|
|
Invert bool `json:"invert,omitempty"`
|
|
|
|
// Deprecated: renamed to rule_set_ip_cidr_match_source
|
|
Deprecated_RulesetIPCIDRMatchSource bool `json:"rule_set_ipcidr_match_source,omitempty" schema:"omit"`
|
|
}
|
|
|
|
type DefaultRule struct {
|
|
RawDefaultRule
|
|
RuleAction
|
|
}
|
|
|
|
func (r DefaultRule) MarshalJSON() ([]byte, error) {
|
|
return badjson.MarshallObjects(r.RawDefaultRule, r.RuleAction)
|
|
}
|
|
|
|
func (r *DefaultRule) UnmarshalJSON(data []byte) error {
|
|
err := json.Unmarshal(data, &r.RawDefaultRule)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return badjson.UnmarshallExcluded(data, &r.RawDefaultRule, &r.RuleAction)
|
|
}
|
|
|
|
func (r DefaultRule) IsValid() bool {
|
|
var defaultValue DefaultRule
|
|
defaultValue.Invert = r.Invert
|
|
return !reflect.DeepEqual(r, defaultValue)
|
|
}
|
|
|
|
type RawLogicalRule struct {
|
|
Mode string `json:"mode" enum:"and,or"`
|
|
Rules []Rule `json:"rules,omitempty"`
|
|
Invert bool `json:"invert,omitempty"`
|
|
}
|
|
|
|
type LogicalRule struct {
|
|
RawLogicalRule
|
|
RuleAction
|
|
}
|
|
|
|
func (r LogicalRule) MarshalJSON() ([]byte, error) {
|
|
return badjson.MarshallObjects(r.RawLogicalRule, r.RuleAction)
|
|
}
|
|
|
|
func (r *LogicalRule) UnmarshalJSON(data []byte) error {
|
|
err := json.Unmarshal(data, &r.RawLogicalRule)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return badjson.UnmarshallExcluded(data, &r.RawLogicalRule, &r.RuleAction)
|
|
}
|
|
|
|
func rulePayloadWithoutType(ctx context.Context, data []byte) ([]byte, error) {
|
|
var content badjson.JSONObject
|
|
err := content.UnmarshalJSONContext(ctx, data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
content.Remove("type")
|
|
return content.MarshalJSONContext(ctx)
|
|
}
|
|
|
|
func unmarshalDefaultRuleContext(ctx context.Context, data []byte, rule *DefaultRule) error {
|
|
rawAction, routeOptions, err := inspectRouteRuleAction(ctx, data)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = rejectNestedRouteRuleAction(ctx, data)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
depth := nestedRuleDepth(ctx)
|
|
err = json.UnmarshalContext(ctx, data, &rule.RawDefaultRule)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = badjson.UnmarshallExcludedContext(ctx, data, &rule.RawDefaultRule, &rule.RuleAction)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if depth > 0 && rawAction == "" && routeOptions == (RouteActionOptions{}) {
|
|
rule.RuleAction = RuleAction{}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func unmarshalLogicalRuleContext(ctx context.Context, data []byte, rule *LogicalRule) error {
|
|
rawAction, routeOptions, err := inspectRouteRuleAction(ctx, data)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = rejectNestedRouteRuleAction(ctx, data)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
depth := nestedRuleDepth(ctx)
|
|
err = json.UnmarshalContext(nestedRuleChildContext(ctx), data, &rule.RawLogicalRule)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = badjson.UnmarshallExcludedContext(ctx, data, &rule.RawLogicalRule, &rule.RuleAction)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if depth > 0 && rawAction == "" && routeOptions == (RouteActionOptions{}) {
|
|
rule.RuleAction = RuleAction{}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *LogicalRule) IsValid() bool {
|
|
return len(r.Rules) > 0 && common.All(r.Rules, Rule.IsValid)
|
|
}
|