mirror of
https://github.com/XTLS/Xray-core.git
synced 2024-11-15 01:09:20 +02:00
131 lines
3.0 KiB
Go
131 lines
3.0 KiB
Go
package router
|
|
|
|
import (
|
|
dm "github.com/xtls/xray-core/common/matcher/domain"
|
|
"github.com/xtls/xray-core/common/matcher/geoip"
|
|
"github.com/xtls/xray-core/common/net"
|
|
"github.com/xtls/xray-core/features/outbound"
|
|
"github.com/xtls/xray-core/features/routing"
|
|
)
|
|
|
|
type Rule struct {
|
|
Tag string
|
|
Balancer *Balancer
|
|
Condition Condition
|
|
}
|
|
|
|
func (r *Rule) GetTag() (string, error) {
|
|
if r.Balancer != nil {
|
|
return r.Balancer.PickOutbound()
|
|
}
|
|
return r.Tag, nil
|
|
}
|
|
|
|
// Apply checks rule matching of current routing context.
|
|
func (r *Rule) Apply(ctx routing.Context) bool {
|
|
return r.Condition.Apply(ctx)
|
|
}
|
|
|
|
func (rr *RoutingRule) BuildCondition() (Condition, error) {
|
|
conds := NewConditionChan()
|
|
|
|
if len(rr.Domain) > 0 {
|
|
switch rr.DomainMatcher {
|
|
case "linear":
|
|
matcher, err := dm.NewDomainMatcher(rr.Domain)
|
|
if err != nil {
|
|
return nil, newError("failed to build domain condition").Base(err)
|
|
}
|
|
conds.Add(matcher)
|
|
case "mph", "hybrid":
|
|
fallthrough
|
|
default:
|
|
matcher, err := dm.NewMphMatcherGroup(rr.Domain)
|
|
if err != nil {
|
|
return nil, newError("failed to build domain condition with MphDomainMatcher").Base(err)
|
|
}
|
|
newError("MphDomainMatcher is enabled for ", len(rr.Domain), " domain rule(s)").AtDebug().WriteToLog()
|
|
conds.Add(matcher)
|
|
}
|
|
|
|
}
|
|
|
|
if len(rr.UserEmail) > 0 {
|
|
conds.Add(NewUserMatcher(rr.UserEmail))
|
|
}
|
|
|
|
if len(rr.InboundTag) > 0 {
|
|
conds.Add(NewInboundTagMatcher(rr.InboundTag))
|
|
}
|
|
|
|
if rr.PortList != nil {
|
|
conds.Add(NewPortMatcher(rr.PortList, false))
|
|
} else if rr.PortRange != nil {
|
|
conds.Add(NewPortMatcher(&net.PortList{Range: []*net.PortRange{rr.PortRange}}, false))
|
|
}
|
|
|
|
if rr.SourcePortList != nil {
|
|
conds.Add(NewPortMatcher(rr.SourcePortList, true))
|
|
}
|
|
|
|
if len(rr.Networks) > 0 {
|
|
conds.Add(NewNetworkMatcher(rr.Networks))
|
|
} else if rr.NetworkList != nil {
|
|
conds.Add(NewNetworkMatcher(rr.NetworkList.Network))
|
|
}
|
|
|
|
if len(rr.Geoip) > 0 {
|
|
cond, err := geoip.NewMultiGeoIPMatcher(rr.Geoip, false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
conds.Add(cond)
|
|
} else if len(rr.Cidr) > 0 {
|
|
cond, err := geoip.NewMultiGeoIPMatcher([]*geoip.GeoIP{{Cidr: rr.Cidr}}, false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
conds.Add(cond)
|
|
}
|
|
|
|
if len(rr.SourceGeoip) > 0 {
|
|
cond, err := geoip.NewMultiGeoIPMatcher(rr.SourceGeoip, true)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
conds.Add(cond)
|
|
} else if len(rr.SourceCidr) > 0 {
|
|
cond, err := geoip.NewMultiGeoIPMatcher([]*geoip.GeoIP{{Cidr: rr.SourceCidr}}, true)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
conds.Add(cond)
|
|
}
|
|
|
|
if len(rr.Protocol) > 0 {
|
|
conds.Add(NewProtocolMatcher(rr.Protocol))
|
|
}
|
|
|
|
if len(rr.Attributes) > 0 {
|
|
cond, err := NewAttributeMatcher(rr.Attributes)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
conds.Add(cond)
|
|
}
|
|
|
|
if conds.Len() == 0 {
|
|
return nil, newError("this rule has no effective fields").AtWarning()
|
|
}
|
|
|
|
return conds, nil
|
|
}
|
|
|
|
func (br *BalancingRule) Build(ohm outbound.Manager) (*Balancer, error) {
|
|
return &Balancer{
|
|
selectors: br.OutboundSelector,
|
|
strategy: &RandomStrategy{},
|
|
ohm: ohm,
|
|
}, nil
|
|
}
|