mirror of
https://github.com/SagerNet/sing-box.git
synced 2024-11-16 07:52:21 +08:00
374 lines
9.6 KiB
Go
374 lines
9.6 KiB
Go
package route
|
|
|
|
import (
|
|
"strings"
|
|
|
|
"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"
|
|
E "github.com/sagernet/sing/common/exceptions"
|
|
F "github.com/sagernet/sing/common/format"
|
|
N "github.com/sagernet/sing/common/network"
|
|
)
|
|
|
|
func NewRule(router adapter.Router, logger log.ContextLogger, options option.Rule) (adapter.Rule, error) {
|
|
switch options.Type {
|
|
case "", C.RuleTypeDefault:
|
|
if !options.DefaultOptions.IsValid() {
|
|
return nil, E.New("missing conditions")
|
|
}
|
|
if options.DefaultOptions.Outbound == "" {
|
|
return nil, E.New("missing outbound field")
|
|
}
|
|
return NewDefaultRule(router, logger, options.DefaultOptions)
|
|
case C.RuleTypeLogical:
|
|
if !options.LogicalOptions.IsValid() {
|
|
return nil, E.New("missing conditions")
|
|
}
|
|
if options.LogicalOptions.Outbound == "" {
|
|
return nil, E.New("missing outbound field")
|
|
}
|
|
return NewLogicalRule(router, logger, options.LogicalOptions)
|
|
default:
|
|
return nil, E.New("unknown rule type: ", options.Type)
|
|
}
|
|
}
|
|
|
|
var _ adapter.Rule = (*DefaultRule)(nil)
|
|
|
|
type DefaultRule struct {
|
|
items []RuleItem
|
|
sourceAddressItems []RuleItem
|
|
destinationAddressItems []RuleItem
|
|
allItems []RuleItem
|
|
invert bool
|
|
outbound string
|
|
}
|
|
|
|
type RuleItem interface {
|
|
Match(metadata *adapter.InboundContext) bool
|
|
String() string
|
|
}
|
|
|
|
func NewDefaultRule(router adapter.Router, logger log.ContextLogger, options option.DefaultRule) (*DefaultRule, error) {
|
|
rule := &DefaultRule{
|
|
invert: options.Invert,
|
|
outbound: options.Outbound,
|
|
}
|
|
if len(options.Inbound) > 0 {
|
|
item := NewInboundRule(options.Inbound)
|
|
rule.items = append(rule.items, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
if options.IPVersion > 0 {
|
|
switch options.IPVersion {
|
|
case 4, 6:
|
|
item := NewIPVersionItem(options.IPVersion == 6)
|
|
rule.items = append(rule.items, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
default:
|
|
return nil, E.New("invalid ip version: ", options.IPVersion)
|
|
}
|
|
}
|
|
if options.Network != "" {
|
|
switch options.Network {
|
|
case N.NetworkTCP, N.NetworkUDP:
|
|
item := NewNetworkItem(options.Network)
|
|
rule.items = append(rule.items, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
default:
|
|
return nil, E.New("invalid network: ", options.Network)
|
|
}
|
|
}
|
|
if len(options.AuthUser) > 0 {
|
|
item := NewAuthUserItem(options.AuthUser)
|
|
rule.items = append(rule.items, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
if len(options.Protocol) > 0 {
|
|
item := NewProtocolItem(options.Protocol)
|
|
rule.items = append(rule.items, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
if len(options.Domain) > 0 || len(options.DomainSuffix) > 0 {
|
|
item := NewDomainItem(options.Domain, options.DomainSuffix)
|
|
rule.destinationAddressItems = append(rule.destinationAddressItems, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
if len(options.DomainKeyword) > 0 {
|
|
item := NewDomainKeywordItem(options.DomainKeyword)
|
|
rule.destinationAddressItems = append(rule.destinationAddressItems, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
if len(options.DomainRegex) > 0 {
|
|
item, err := NewDomainRegexItem(options.DomainRegex)
|
|
if err != nil {
|
|
return nil, E.Cause(err, "domain_regex")
|
|
}
|
|
rule.destinationAddressItems = append(rule.destinationAddressItems, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
if len(options.Geosite) > 0 {
|
|
item := NewGeositeItem(router, logger, options.Geosite)
|
|
rule.destinationAddressItems = append(rule.destinationAddressItems, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
if len(options.SourceGeoIP) > 0 {
|
|
item := NewGeoIPItem(router, logger, true, options.SourceGeoIP)
|
|
rule.sourceAddressItems = append(rule.sourceAddressItems, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
if len(options.GeoIP) > 0 {
|
|
item := NewGeoIPItem(router, logger, false, options.GeoIP)
|
|
rule.destinationAddressItems = append(rule.destinationAddressItems, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
if len(options.SourceIPCIDR) > 0 {
|
|
item, err := NewIPCIDRItem(true, options.SourceIPCIDR)
|
|
if err != nil {
|
|
return nil, E.Cause(err, "source_ipcidr")
|
|
}
|
|
rule.sourceAddressItems = append(rule.sourceAddressItems, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
if len(options.IPCIDR) > 0 {
|
|
item, err := NewIPCIDRItem(false, options.IPCIDR)
|
|
if err != nil {
|
|
return nil, E.Cause(err, "ipcidr")
|
|
}
|
|
rule.destinationAddressItems = append(rule.destinationAddressItems, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
if len(options.SourcePort) > 0 {
|
|
item := NewPortItem(true, options.SourcePort)
|
|
rule.items = append(rule.items, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
if len(options.SourcePortRange) > 0 {
|
|
item, err := NewPortRangeItem(true, options.SourcePortRange)
|
|
if err != nil {
|
|
return nil, E.Cause(err, "source_port_range")
|
|
}
|
|
rule.items = append(rule.items, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
if len(options.Port) > 0 {
|
|
item := NewPortItem(false, options.Port)
|
|
rule.items = append(rule.items, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
if len(options.PortRange) > 0 {
|
|
item, err := NewPortRangeItem(false, options.PortRange)
|
|
if err != nil {
|
|
return nil, E.Cause(err, "port_range")
|
|
}
|
|
rule.items = append(rule.items, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
if len(options.ProcessName) > 0 {
|
|
item := NewProcessItem(options.ProcessName)
|
|
rule.items = append(rule.items, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
if len(options.PackageName) > 0 {
|
|
item := NewPackageNameItem(options.PackageName)
|
|
rule.items = append(rule.items, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
if len(options.User) > 0 {
|
|
item := NewUserItem(options.User)
|
|
rule.items = append(rule.items, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
if len(options.UserID) > 0 {
|
|
item := NewUserIDItem(options.UserID)
|
|
rule.items = append(rule.items, item)
|
|
rule.allItems = append(rule.allItems, item)
|
|
}
|
|
return rule, nil
|
|
}
|
|
|
|
func (r *DefaultRule) Type() string {
|
|
return C.RuleTypeDefault
|
|
}
|
|
|
|
func (r *DefaultRule) Start() error {
|
|
for _, item := range r.allItems {
|
|
err := common.Start(item)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *DefaultRule) Close() error {
|
|
for _, item := range r.allItems {
|
|
err := common.Close(item)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *DefaultRule) UpdateGeosite() error {
|
|
for _, item := range r.allItems {
|
|
if geositeItem, isSite := item.(*GeositeItem); isSite {
|
|
err := geositeItem.Update()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *DefaultRule) Match(metadata *adapter.InboundContext) bool {
|
|
for _, item := range r.items {
|
|
if !item.Match(metadata) {
|
|
return r.invert
|
|
}
|
|
}
|
|
|
|
if len(r.sourceAddressItems) > 0 {
|
|
var sourceAddressMatch bool
|
|
for _, item := range r.sourceAddressItems {
|
|
if item.Match(metadata) {
|
|
sourceAddressMatch = true
|
|
break
|
|
}
|
|
}
|
|
if !sourceAddressMatch {
|
|
return r.invert
|
|
}
|
|
}
|
|
|
|
if len(r.destinationAddressItems) > 0 {
|
|
var destinationAddressMatch bool
|
|
for _, item := range r.destinationAddressItems {
|
|
if item.Match(metadata) {
|
|
destinationAddressMatch = true
|
|
break
|
|
}
|
|
}
|
|
if !destinationAddressMatch {
|
|
return r.invert
|
|
}
|
|
}
|
|
|
|
return !r.invert
|
|
}
|
|
|
|
func (r *DefaultRule) Outbound() string {
|
|
return r.outbound
|
|
}
|
|
|
|
func (r *DefaultRule) String() string {
|
|
if !r.invert {
|
|
return strings.Join(F.MapToString(r.allItems), " ")
|
|
} else {
|
|
return "!(" + strings.Join(F.MapToString(r.allItems), " ") + ")"
|
|
}
|
|
}
|
|
|
|
var _ adapter.Rule = (*LogicalRule)(nil)
|
|
|
|
type LogicalRule struct {
|
|
mode string
|
|
rules []*DefaultRule
|
|
invert bool
|
|
outbound string
|
|
}
|
|
|
|
func NewLogicalRule(router adapter.Router, logger log.ContextLogger, options option.LogicalRule) (*LogicalRule, error) {
|
|
r := &LogicalRule{
|
|
rules: make([]*DefaultRule, len(options.Rules)),
|
|
invert: options.Invert,
|
|
outbound: options.Outbound,
|
|
}
|
|
switch options.Mode {
|
|
case C.LogicalTypeAnd:
|
|
r.mode = C.LogicalTypeAnd
|
|
case C.LogicalTypeOr:
|
|
r.mode = C.LogicalTypeOr
|
|
default:
|
|
return nil, E.New("unknown logical mode: ", options.Mode)
|
|
}
|
|
for i, subRule := range options.Rules {
|
|
rule, err := NewDefaultRule(router, logger, subRule)
|
|
if err != nil {
|
|
return nil, E.Cause(err, "sub rule[", i, "]")
|
|
}
|
|
r.rules[i] = rule
|
|
}
|
|
return r, nil
|
|
}
|
|
|
|
func (r *LogicalRule) Type() string {
|
|
return C.RuleTypeLogical
|
|
}
|
|
|
|
func (r *LogicalRule) UpdateGeosite() error {
|
|
for _, rule := range r.rules {
|
|
err := rule.UpdateGeosite()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *LogicalRule) Start() error {
|
|
for _, rule := range r.rules {
|
|
err := rule.Start()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *LogicalRule) Close() error {
|
|
for _, rule := range r.rules {
|
|
err := rule.Close()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *LogicalRule) Match(metadata *adapter.InboundContext) bool {
|
|
if r.mode == C.LogicalTypeAnd {
|
|
return common.All(r.rules, func(it *DefaultRule) bool {
|
|
return it.Match(metadata)
|
|
}) != r.invert
|
|
} else {
|
|
return common.Any(r.rules, func(it *DefaultRule) bool {
|
|
return it.Match(metadata)
|
|
}) != r.invert
|
|
}
|
|
}
|
|
|
|
func (r *LogicalRule) Outbound() string {
|
|
return r.outbound
|
|
}
|
|
|
|
func (r *LogicalRule) String() string {
|
|
var op string
|
|
switch r.mode {
|
|
case C.LogicalTypeAnd:
|
|
op = "&&"
|
|
case C.LogicalTypeOr:
|
|
op = "||"
|
|
}
|
|
if !r.invert {
|
|
return strings.Join(F.MapToString(r.rules), " "+op+" ")
|
|
} else {
|
|
return "!(" + strings.Join(F.MapToString(r.rules), " "+op+" ") + ")"
|
|
}
|
|
}
|