mirror of
https://github.com/v2fly/v2ray-core.git
synced 2024-12-22 18:17:52 -05:00
239 lines
6.0 KiB
Go
239 lines
6.0 KiB
Go
package conf
|
|
|
|
import (
|
|
"encoding/json"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"v2ray.com/core/app/log"
|
|
"v2ray.com/core/app/router"
|
|
"v2ray.com/core/common/errors"
|
|
v2net "v2ray.com/core/common/net"
|
|
"v2ray.com/core/tools/geoip"
|
|
|
|
"github.com/golang/protobuf/proto"
|
|
)
|
|
|
|
type RouterRulesConfig struct {
|
|
RuleList []json.RawMessage `json:"rules"`
|
|
DomainStrategy string `json:"domainStrategy"`
|
|
}
|
|
|
|
type RouterConfig struct {
|
|
Settings *RouterRulesConfig `json:"settings"`
|
|
}
|
|
|
|
func (v *RouterConfig) Build() (*router.Config, error) {
|
|
if v.Settings == nil {
|
|
return nil, errors.New("Config: Router settings is not specified.")
|
|
}
|
|
config := new(router.Config)
|
|
|
|
settings := v.Settings
|
|
config.DomainStrategy = router.Config_AsIs
|
|
config.Rule = make([]*router.RoutingRule, len(settings.RuleList))
|
|
domainStrategy := strings.ToLower(settings.DomainStrategy)
|
|
if domainStrategy == "alwaysip" {
|
|
config.DomainStrategy = router.Config_UseIp
|
|
} else if domainStrategy == "ipifnonmatch" {
|
|
config.DomainStrategy = router.Config_IpIfNonMatch
|
|
}
|
|
for idx, rawRule := range settings.RuleList {
|
|
rule, err := ParseRule(rawRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
config.Rule[idx] = rule
|
|
}
|
|
return config, nil
|
|
}
|
|
|
|
type RouterRule struct {
|
|
Type string `json:"type"`
|
|
OutboundTag string `json:"outboundTag"`
|
|
}
|
|
|
|
func parseIP(s string) (*router.CIDR, error) {
|
|
var addr, mask string
|
|
i := strings.Index(s, "/")
|
|
if i < 0 {
|
|
addr = s
|
|
} else {
|
|
addr = s[:i]
|
|
mask = s[i+1:]
|
|
}
|
|
ip := v2net.ParseAddress(addr)
|
|
switch ip.Family() {
|
|
case v2net.AddressFamilyIPv4:
|
|
bits := uint32(32)
|
|
if len(mask) > 0 {
|
|
bits64, err := strconv.ParseUint(mask, 10, 32)
|
|
if err != nil {
|
|
return nil, errors.Base(err).Message("Config: invalid network mask for router: ", mask)
|
|
}
|
|
bits = uint32(bits64)
|
|
}
|
|
if bits > 32 {
|
|
return nil, errors.New("Config: invalid network mask for router: ", bits)
|
|
}
|
|
return &router.CIDR{
|
|
Ip: []byte(ip.IP()),
|
|
Prefix: bits,
|
|
}, nil
|
|
case v2net.AddressFamilyIPv6:
|
|
bits := uint32(128)
|
|
if len(mask) > 0 {
|
|
bits64, err := strconv.ParseUint(mask, 10, 32)
|
|
if err != nil {
|
|
return nil, errors.Base(err).Message("Config: invalid network mask for router: ", mask)
|
|
}
|
|
bits = uint32(bits64)
|
|
}
|
|
if bits > 128 {
|
|
return nil, errors.New("Config: invalid network mask for router: ", bits)
|
|
}
|
|
return &router.CIDR{
|
|
Ip: []byte(ip.IP()),
|
|
Prefix: bits,
|
|
}, nil
|
|
default:
|
|
return nil, errors.New("Config: unsupported address for router: ", s)
|
|
}
|
|
}
|
|
|
|
func parseFieldRule(msg json.RawMessage) (*router.RoutingRule, error) {
|
|
type RawFieldRule struct {
|
|
RouterRule
|
|
Domain *StringList `json:"domain"`
|
|
IP *StringList `json:"ip"`
|
|
Port *PortRange `json:"port"`
|
|
Network *NetworkList `json:"network"`
|
|
SourceIP *StringList `json:"source"`
|
|
User *StringList `json:"user"`
|
|
InboundTag *StringList `json:"inboundTag"`
|
|
}
|
|
rawFieldRule := new(RawFieldRule)
|
|
err := json.Unmarshal(msg, rawFieldRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
rule := new(router.RoutingRule)
|
|
rule.Tag = rawFieldRule.OutboundTag
|
|
|
|
if rawFieldRule.Domain != nil {
|
|
for _, domain := range *rawFieldRule.Domain {
|
|
domainRule := new(router.Domain)
|
|
if strings.HasPrefix(domain, "regexp:") {
|
|
domainRule.Type = router.Domain_Regex
|
|
domainRule.Value = domain[7:]
|
|
} else {
|
|
domainRule.Type = router.Domain_Plain
|
|
domainRule.Value = domain
|
|
}
|
|
rule.Domain = append(rule.Domain, domainRule)
|
|
}
|
|
}
|
|
|
|
if rawFieldRule.IP != nil {
|
|
for _, ip := range *rawFieldRule.IP {
|
|
ipRule, err := parseIP(ip)
|
|
if err != nil {
|
|
return nil, errors.Base(err).Message("Config: invalid IP: ", ip)
|
|
}
|
|
rule.Cidr = append(rule.Cidr, ipRule)
|
|
}
|
|
}
|
|
|
|
if rawFieldRule.Port != nil {
|
|
rule.PortRange = rawFieldRule.Port.Build()
|
|
}
|
|
|
|
if rawFieldRule.Network != nil {
|
|
rule.NetworkList = rawFieldRule.Network.Build()
|
|
}
|
|
|
|
if rawFieldRule.SourceIP != nil {
|
|
for _, ip := range *rawFieldRule.SourceIP {
|
|
ipRule, err := parseIP(ip)
|
|
if err != nil {
|
|
return nil, errors.Base(err).Message("Config: invalid IP: ", ip)
|
|
}
|
|
rule.SourceCidr = append(rule.SourceCidr, ipRule)
|
|
}
|
|
}
|
|
|
|
if rawFieldRule.User != nil {
|
|
for _, s := range *rawFieldRule.User {
|
|
rule.UserEmail = append(rule.UserEmail, s)
|
|
}
|
|
}
|
|
|
|
if rawFieldRule.InboundTag != nil {
|
|
for _, s := range *rawFieldRule.InboundTag {
|
|
rule.InboundTag = append(rule.InboundTag, s)
|
|
}
|
|
}
|
|
|
|
return rule, nil
|
|
}
|
|
|
|
func ParseRule(msg json.RawMessage) (*router.RoutingRule, error) {
|
|
rawRule := new(RouterRule)
|
|
err := json.Unmarshal(msg, rawRule)
|
|
if err != nil {
|
|
return nil, errors.Base(err).Message("Config: Invalid router rule.")
|
|
}
|
|
if rawRule.Type == "field" {
|
|
fieldrule, err := parseFieldRule(msg)
|
|
if err != nil {
|
|
return nil, errors.Base(err).Message("Config: Invalid field rule.")
|
|
}
|
|
return fieldrule, nil
|
|
}
|
|
if rawRule.Type == "chinaip" {
|
|
chinaiprule, err := parseChinaIPRule(msg)
|
|
if err != nil {
|
|
return nil, errors.Base(err).Message("Config: Invalid chinaip rule.")
|
|
}
|
|
return chinaiprule, nil
|
|
}
|
|
if rawRule.Type == "chinasites" {
|
|
chinasitesrule, err := parseChinaSitesRule(msg)
|
|
if err != nil {
|
|
return nil, errors.Base(err).Message("Config: Invalid chinasites rule.")
|
|
}
|
|
return chinasitesrule, nil
|
|
}
|
|
return nil, errors.New("Config: Unknown router rule type: ", rawRule.Type)
|
|
}
|
|
|
|
func parseChinaIPRule(data []byte) (*router.RoutingRule, error) {
|
|
rawRule := new(RouterRule)
|
|
err := json.Unmarshal(data, rawRule)
|
|
if err != nil {
|
|
return nil, errors.Base(err).Message("Config: Invalid router rule.")
|
|
}
|
|
var chinaIPs geoip.CountryIPRange
|
|
if err := proto.Unmarshal(geoip.ChinaIPs, &chinaIPs); err != nil {
|
|
return nil, errors.Base(err).Message("Config: Invalid china ips.")
|
|
}
|
|
return &router.RoutingRule{
|
|
Tag: rawRule.OutboundTag,
|
|
Cidr: chinaIPs.Ips,
|
|
}, nil
|
|
}
|
|
|
|
func parseChinaSitesRule(data []byte) (*router.RoutingRule, error) {
|
|
rawRule := new(RouterRule)
|
|
err := json.Unmarshal(data, rawRule)
|
|
if err != nil {
|
|
log.Error("Router: Invalid router rule: ", err)
|
|
return nil, err
|
|
}
|
|
return &router.RoutingRule{
|
|
Tag: rawRule.OutboundTag,
|
|
Domain: chinaSitesDomains,
|
|
}, nil
|
|
}
|