official server configuration

See: https://github.com/travis-ci/travis-ci/issues/5145

.travis.yml

@@ -9,13 +9,15 @@ before_install:
   - go get github.com/mattn/goveralls
 
 script:
-    - go test github.com/v2ray/v2ray-core/...
-    - ./testing/coverage/coverall
+  - go test github.com/v2ray/v2ray-core/...
+  - ./testing/coverage/coverall
 
 env:
   secure: "nnEiGTuS8SsSFRpxUsPh6hmx/OfPDA6AO3OX7IpjPCbkQnjuFEsm3DfPEZOHTiYra00Ea3bNw9ePLPqyWdLAPmcLoUBhWRyfevt9m3jrbyrT8O9MCXNDY6i1ll3E43nx8kxRDF1QbYaSK4jppa8Vu2vyZH5+GiS0JVcw/7CfX8TyUMbDuyaQXYQ1kwixlThQZH43xxQ7u5CFF1pBFdwpkuDm2/wKUE+0CGZOeWzUYI8h1in4eY0Vse4Zt4GqS2eywf4rw12bBysZ21UnT/xu990m5nzAScbUGjloplJNpdZGtD8SBTGujZBMMUzKi/E0zJkdEf37MZ9rsarfv6v9khdwTp/8VoAiZxpG1IDISIu0TClAjw8NYO5hmuF01/oJexMuxqRhMPwbk1nPsustlBKEG3zjvW5yILMkiaRl67Pj+9h21zMGYmwPGka7Ollh9ki2h17RFNuj9Yxm5XX2xvZDIvtxL1a8S50vv7VZTT9rrrFMhGP7ty9gj2opjJ7QBgwi2W/eVGhfshfnZJjJ7Bqf+gl1MDOYcTlqmFe5JvKdIO9mN7gskJizmeFxh31LrZ2sCY71/iicGj7gZJ4e/u2/dI2OVfFWTTbHoiIyCLvvrA18zBF9Sky1Y3QDj85GdRtC0SI6TXJLAIa7jNgF6Nr2mAg044DaX9VW0VH0VnE="
 
-before_deploy: "./release/release.sh"
+before_deploy:
+  - rvm 1.9.3 do gem install mime-types -v 2.6.2
+  - "./release/release.sh"
 
 deploy:
   provider: releases

app/point/config/config.go

@@ -1,5 +1,10 @@
 package config
 
+import (
+	routerconfig "github.com/v2ray/v2ray-core/app/router/config"
+	v2net "github.com/v2ray/v2ray-core/common/net"
+)
+
 type DetourTag string
 
 type ConnectionConfig interface {
@@ -11,14 +16,9 @@ type LogConfig interface {
 	AccessLog() string
 }
 
-type PortRange interface {
-	From() uint16
-	To() uint16
-}
-
 type InboundDetourConfig interface {
 	Protocol() string
-	PortRange() PortRange
+	PortRange() v2net.PortRange
 	Settings() interface{}
 }
 
@@ -31,7 +31,9 @@ type OutboundDetourConfig interface {
 type PointConfig interface {
 	Port() uint16
 	LogConfig() LogConfig
+	RouterConfig() routerconfig.RouterConfig
 	InboundConfig() ConnectionConfig
 	OutboundConfig() ConnectionConfig
 	InboundDetours() []InboundDetourConfig
+	OutboundDetours() []OutboundDetourConfig
 }

app/point/config/json/inbound_detour.go

@@ -3,21 +3,22 @@ package json
 import (
 	"encoding/json"
 
-	"github.com/v2ray/v2ray-core/app/point/config"
+	v2net "github.com/v2ray/v2ray-core/common/net"
+	v2netjson "github.com/v2ray/v2ray-core/common/net/json"
 	proxyconfig "github.com/v2ray/v2ray-core/proxy/common/config"
 )
 
 type InboundDetourConfig struct {
-	ProtocolValue  string          `json:"protocol"`
-	PortRangeValue *PortRange      `json:"port"`
-	SettingsValue  json.RawMessage `json:"settings"`
+	ProtocolValue  string               `json:"protocol"`
+	PortRangeValue *v2netjson.PortRange `json:"port"`
+	SettingsValue  json.RawMessage      `json:"settings"`
 }
 
 func (this *InboundDetourConfig) Protocol() string {
 	return this.ProtocolValue
 }
 
-func (this *InboundDetourConfig) PortRange() config.PortRange {
+func (this *InboundDetourConfig) PortRange() v2net.PortRange {
 	return this.PortRangeValue
 }
 

app/point/config/json/json.go

@@ -6,18 +6,21 @@ import (
 	"os"
 
 	"github.com/v2ray/v2ray-core/app/point/config"
+	routerconfig "github.com/v2ray/v2ray-core/app/router/config"
+	routerconfigjson "github.com/v2ray/v2ray-core/app/router/config/json"
 	"github.com/v2ray/v2ray-core/common/log"
 	proxyconfig "github.com/v2ray/v2ray-core/proxy/common/config"
 )
 
 // Config is the config for Point server.
 type Config struct {
-	PortValue            uint16                  `json:"port"` // Port of this Point server.
-	LogConfigValue       *LogConfig              `json:"log"`
-	InboundConfigValue   *ConnectionConfig       `json:"inbound"`
-	OutboundConfigValue  *ConnectionConfig       `json:"outbound"`
-	InboundDetoursValue  []*InboundDetourConfig  `json:"inboundDetour"`
-	OutboundDetoursValue []*OutboundDetourConfig `json:"outboundDetour"`
+	PortValue            uint16                         `json:"port"` // Port of this Point server.
+	LogConfigValue       *LogConfig                     `json:"log"`
+	RouterConfigValue    *routerconfigjson.RouterConfig `json:"routing"`
+	InboundConfigValue   *ConnectionConfig              `json:"inbound"`
+	OutboundConfigValue  *ConnectionConfig              `json:"outbound"`
+	InboundDetoursValue  []*InboundDetourConfig         `json:"inboundDetour"`
+	OutboundDetoursValue []*OutboundDetourConfig        `json:"outboundDetour"`
 }
 
 func (config *Config) Port() uint16 {
@@ -31,6 +34,13 @@ func (config *Config) LogConfig() config.LogConfig {
 	return config.LogConfigValue
 }
 
+func (this *Config) RouterConfig() routerconfig.RouterConfig {
+	if this.RouterConfigValue == nil {
+		return nil
+	}
+	return this.RouterConfigValue
+}
+
 func (config *Config) InboundConfig() config.ConnectionConfig {
 	if config.InboundConfigValue == nil {
 		return nil

app/point/config/testing/mocks/config.go

@@ -2,6 +2,8 @@ package mocks
 
 import (
 	"github.com/v2ray/v2ray-core/app/point/config"
+	routerconfig "github.com/v2ray/v2ray-core/app/router/config"
+	v2net "github.com/v2ray/v2ray-core/common/net"
 )
 
 type ConnectionConfig struct {
@@ -39,20 +41,31 @@ type InboundDetourConfig struct {
 	PortRangeValue *PortRange
 }
 
-func (this *InboundDetourConfig) PortRange() config.PortRange {
+func (this *InboundDetourConfig) PortRange() v2net.PortRange {
 	return this.PortRangeValue
 }
 
+type OutboundDetourConfig struct {
+	ConnectionConfig
+	TagValue config.DetourTag
+}
+
+func (this *OutboundDetourConfig) Tag() config.DetourTag {
+	return this.TagValue
+}
+
 func (config *LogConfig) AccessLog() string {
 	return config.AccessLogValue
 }
 
 type Config struct {
-	PortValue           uint16
-	LogConfigValue      *LogConfig
-	InboundConfigValue  *ConnectionConfig
-	OutboundConfigValue *ConnectionConfig
-	InboundDetoursValue []*InboundDetourConfig
+	PortValue            uint16
+	LogConfigValue       *LogConfig
+	RouterConfigValue    routerconfig.RouterConfig
+	InboundConfigValue   *ConnectionConfig
+	OutboundConfigValue  *ConnectionConfig
+	InboundDetoursValue  []*InboundDetourConfig
+	OutboundDetoursValue []*OutboundDetourConfig
 }
 
 func (config *Config) Port() uint16 {
@@ -63,6 +76,10 @@ func (config *Config) LogConfig() config.LogConfig {
 	return config.LogConfigValue
 }
 
+func (this *Config) RouterConfig() routerconfig.RouterConfig {
+	return this.RouterConfigValue
+}
+
 func (config *Config) InboundConfig() config.ConnectionConfig {
 	return config.InboundConfigValue
 }
@@ -78,3 +95,11 @@ func (this *Config) InboundDetours() []config.InboundDetourConfig {
 	}
 	return detours
 }
+
+func (this *Config) OutboundDetours() []config.OutboundDetourConfig {
+	detours := make([]config.OutboundDetourConfig, len(this.OutboundDetoursValue))
+	for idx, detour := range this.OutboundDetoursValue {
+		detours[idx] = detour
+	}
+	return detours
+}

app/point/point.go

@@ -2,6 +2,7 @@ package point
 
 import (
 	"github.com/v2ray/v2ray-core/app/point/config"
+	"github.com/v2ray/v2ray-core/app/router"
 	"github.com/v2ray/v2ray-core/common/log"
 	v2net "github.com/v2ray/v2ray-core/common/net"
 	"github.com/v2ray/v2ray-core/common/retry"
@@ -11,10 +12,12 @@ import (
 
 // Point is an single server in V2Ray system.
 type Point struct {
-	port uint16
-	ich  connhandler.InboundConnectionHandler
-	och  connhandler.OutboundConnectionHandler
-	idh  []*InboundDetourHandler
+	port   uint16
+	ich    connhandler.InboundConnectionHandler
+	och    connhandler.OutboundConnectionHandler
+	idh    []*InboundDetourHandler
+	odh    map[config.DetourTag]connhandler.OutboundConnectionHandler
+	router router.Router
 }
 
 // NewPoint returns a new Point server based on given configuration.
@@ -65,6 +68,34 @@ func NewPoint(pConfig config.PointConfig) (*Point, error) {
 		}
 	}
 
+	outboundDetours := pConfig.OutboundDetours()
+	if len(outboundDetours) > 0 {
+		vpoint.odh = make(map[config.DetourTag]connhandler.OutboundConnectionHandler)
+		for _, detourConfig := range outboundDetours {
+			detourFactory := connhandler.GetOutboundConnectionHandlerFactory(detourConfig.Protocol())
+			if detourFactory == nil {
+				log.Error("Unknown detour outbound connection handler factory %s", detourConfig.Protocol())
+				return nil, config.BadConfiguration
+			}
+			detourHandler, err := detourFactory.Create(detourConfig.Settings())
+			if err != nil {
+				log.Error("Failed to create detour outbound connection handler: %v", err)
+				return nil, err
+			}
+			vpoint.odh[detourConfig.Tag()] = detourHandler
+		}
+	}
+
+	routerConfig := pConfig.RouterConfig()
+	if routerConfig != nil {
+		r, err := router.CreateRouter(routerConfig.Strategy(), routerConfig.Settings())
+		if err != nil {
+			log.Error("Failed to create router: %v", err)
+			return nil, config.BadConfiguration
+		}
+		vpoint.router = r
+	}
+
 	return vpoint, nil
 }
 
@@ -100,6 +131,19 @@ func (vp *Point) Start() error {
 
 func (p *Point) DispatchToOutbound(packet v2net.Packet) ray.InboundRay {
 	direct := ray.NewRay()
+	dest := packet.Destination()
+
+	if p.router != nil {
+		tag, err := p.router.TakeDetour(dest)
+		if err == nil {
+			handler, found := p.odh[tag]
+			if found {
+				go handler.Dispatch(packet, direct)
+				return direct
+			}
+		}
+	}
+
 	go p.och.Dispatch(packet, direct)
 	return direct
 }

app/router/config/json/json.go

@@ -2,6 +2,8 @@ package json
 
 import (
 	"encoding/json"
+
+	"github.com/v2ray/v2ray-core/common/log"
 )
 
 type RouterConfig struct {
@@ -14,5 +16,11 @@ func (this *RouterConfig) Strategy() string {
 }
 
 func (this *RouterConfig) Settings() interface{} {
-	return CreateRouterConfig(this.Strategy())
+	settings := CreateRouterConfig(this.Strategy())
+	err := json.Unmarshal(this.SettingsValue, settings)
+	if err != nil {
+		log.Error("Failed to load router settings: %v", err)
+		return nil
+	}
+	return settings
 }

app/router/router.go

@@ -12,7 +12,7 @@ var (
 )
 
 type Router interface {
-	TakeDetour(v2net.Packet) (config.DetourTag, error)
+	TakeDetour(v2net.Destination) (config.DetourTag, error)
 }
 
 type RouterFactory interface {

app/router/rules/config/json/fieldrule.go

@@ -0,0 +1,145 @@
+package json
+
+import (
+	"encoding/json"
+	"errors"
+	"net"
+	"strings"
+
+	v2net "github.com/v2ray/v2ray-core/common/net"
+	v2netjson "github.com/v2ray/v2ray-core/common/net/json"
+)
+
+type StringList []string
+
+func NewStringList(str ...string) *StringList {
+	list := StringList(str)
+	return &list
+}
+
+func (this *StringList) UnmarshalJSON(data []byte) error {
+	var strList []string
+	err := json.Unmarshal(data, &strList)
+	if err == nil {
+		*this = make([]string, len(strList))
+		copy(*this, strList)
+		return nil
+	}
+
+	var str string
+	err = json.Unmarshal(data, &str)
+	if err == nil {
+		*this = make([]string, 0, 1)
+		*this = append(*this, str)
+		return nil
+	}
+
+	return errors.New("Failed to unmarshal string list: " + string(data))
+}
+
+func (this *StringList) Len() int {
+	return len([]string(*this))
+}
+
+type FieldRule struct {
+	Rule
+	Domain  *StringList
+	IP      []*net.IPNet
+	Port    v2net.PortRange
+	Network v2net.NetworkList
+}
+
+func (this *FieldRule) Apply(dest v2net.Destination) bool {
+	address := dest.Address()
+	if this.Domain != nil && this.Domain.Len() > 0 {
+		if !address.IsDomain() {
+			return false
+		}
+		foundMatch := false
+		for _, domain := range *this.Domain {
+			if strings.Contains(address.Domain(), domain) {
+				foundMatch = true
+			}
+		}
+		if !foundMatch {
+			return false
+		}
+	}
+
+	if this.IP != nil && len(this.IP) > 0 {
+		if !(address.IsIPv4() || address.IsIPv6()) {
+			return false
+		}
+		foundMatch := false
+		for _, ipnet := range this.IP {
+			if ipnet.Contains(address.IP()) {
+				foundMatch = true
+			}
+		}
+		if !foundMatch {
+			return false
+		}
+	}
+
+	if this.Port != nil {
+		port := address.Port()
+		if port < this.Port.From() || port > this.Port.To() {
+			return false
+		}
+	}
+
+	if this.Network != nil {
+		if !this.Network.HasNetwork(v2net.Network(dest.Network())) {
+			return false
+		}
+	}
+
+	return true
+}
+
+func (this *FieldRule) UnmarshalJSON(data []byte) error {
+	type RawFieldRule struct {
+		Rule
+		Domain  *StringList            `json:"domain"`
+		IP      *StringList            `json:"ip"`
+		Port    *v2netjson.PortRange   `json:"port"`
+		Network *v2netjson.NetworkList `json:"network"`
+	}
+	rawFieldRule := RawFieldRule{}
+	err := json.Unmarshal(data, &rawFieldRule)
+	if err != nil {
+		return err
+	}
+	this.Type = rawFieldRule.Type
+	this.OutboundTag = rawFieldRule.OutboundTag
+
+	hasField := false
+	if rawFieldRule.Domain != nil && rawFieldRule.Domain.Len() > 0 {
+		this.Domain = rawFieldRule.Domain
+		hasField = true
+	}
+
+	if rawFieldRule.IP != nil && rawFieldRule.IP.Len() > 0 {
+		this.IP = make([]*net.IPNet, 0, rawFieldRule.IP.Len())
+		for _, ipStr := range *(rawFieldRule.IP) {
+			_, ipNet, err := net.ParseCIDR(ipStr)
+			if err != nil {
+				return errors.New("Invalid IP range in router rule: " + err.Error())
+			}
+			this.IP = append(this.IP, ipNet)
+		}
+		hasField = true
+	}
+	if rawFieldRule.Port != nil {
+		this.Port = rawFieldRule.Port
+		hasField = true
+	}
+	if rawFieldRule.Network != nil {
+		this.Network = rawFieldRule.Network
+		hasField = true
+	}
+	if !hasField {
+		return errors.New("This rule has no effective fields.")
+	}
+	return nil
+}

app/router/rules/config/json/fieldrule_test.go

@@ -0,0 +1,105 @@
+package json
+
+import (
+	"encoding/json"
+	"testing"
+
+	v2net "github.com/v2ray/v2ray-core/common/net"
+	v2nettesting "github.com/v2ray/v2ray-core/common/net/testing"
+	"github.com/v2ray/v2ray-core/testing/unit"
+)
+
+func TestStringListParsingList(t *testing.T) {
+	assert := unit.Assert(t)
+
+	rawJson := `["a", "b", "c", "d"]`
+	var strList StringList
+	err := json.Unmarshal([]byte(rawJson), &strList)
+	assert.Error(err).IsNil()
+	assert.Int(strList.Len()).Equals(4)
+}
+
+func TestStringListParsingString(t *testing.T) {
+	assert := unit.Assert(t)
+
+	rawJson := `"abcd"`
+	var strList StringList
+	err := json.Unmarshal([]byte(rawJson), &strList)
+	assert.Error(err).IsNil()
+	assert.Int(strList.Len()).Equals(1)
+}
+
+func TestDomainMatching(t *testing.T) {
+	assert := unit.Assert(t)
+
+	rule := &FieldRule{
+		Domain: NewStringList("v2ray.com"),
+	}
+	dest := v2net.NewTCPDestination(v2net.DomainAddress("www.v2ray.com", 80))
+	assert.Bool(rule.Apply(dest)).IsTrue()
+}
+
+func TestPortMatching(t *testing.T) {
+	assert := unit.Assert(t)
+
+	rule := &FieldRule{
+		Port: &v2nettesting.PortRange{
+			FromValue: 0,
+			ToValue:   100,
+		},
+	}
+	dest := v2net.NewTCPDestination(v2net.DomainAddress("www.v2ray.com", 80))
+	assert.Bool(rule.Apply(dest)).IsTrue()
+}
+
+func TestIPMatching(t *testing.T) {
+	assert := unit.Assert(t)
+
+	rawJson := `{
+    "type": "field",
+    "ip": "10.0.0.0/8",
+    "tag": "test"
+  }`
+	rule := parseRule([]byte(rawJson))
+	dest := v2net.NewTCPDestination(v2net.IPAddress([]byte{10, 0, 0, 1}, 80))
+	assert.Bool(rule.Apply(dest)).IsTrue()
+}
+
+func TestPortNotMatching(t *testing.T) {
+	assert := unit.Assert(t)
+
+	rawJson := `{
+    "type": "field",
+    "port": "80-100",
+    "tag": "test"
+  }`
+	rule := parseRule([]byte(rawJson))
+	dest := v2net.NewTCPDestination(v2net.IPAddress([]byte{10, 0, 0, 1}, 79))
+	assert.Bool(rule.Apply(dest)).IsFalse()
+}
+
+func TestDomainNotMatching(t *testing.T) {
+	assert := unit.Assert(t)
+
+	rawJson := `{
+    "type": "field",
+    "domain": ["google.com", "v2ray.com"],
+    "tag": "test"
+  }`
+	rule := parseRule([]byte(rawJson))
+	dest := v2net.NewTCPDestination(v2net.IPAddress([]byte{10, 0, 0, 1}, 80))
+	assert.Bool(rule.Apply(dest)).IsFalse()
+}
+
+func TestDomainNotMatchingDomain(t *testing.T) {
+	assert := unit.Assert(t)
+
+	rawJson := `{
+    "type": "field",
+    "domain": ["google.com", "v2ray.com"],
+    "tag": "test"
+  }`
+	rule := parseRule([]byte(rawJson))
+	dest := v2net.NewTCPDestination(v2net.DomainAddress("baidu.com", 80))
+	assert.Bool(rule.Apply(dest)).IsFalse()
+}

app/router/rules/config/json/router.go

@@ -0,0 +1,47 @@
+package json
+
+import (
+	"encoding/json"
+
+	v2routerconfigjson "github.com/v2ray/v2ray-core/app/router/config/json"
+	"github.com/v2ray/v2ray-core/app/router/rules/config"
+	"github.com/v2ray/v2ray-core/common/log"
+)
+
+type RouterRuleConfig struct {
+	RuleList []json.RawMessage `json:"rules"`
+}
+
+func parseRule(msg json.RawMessage) config.Rule {
+	rule := new(Rule)
+	err := json.Unmarshal(msg, rule)
+	if err != nil {
+		log.Error("Invalid router rule: %v", err)
+		return nil
+	}
+	if rule.Type == "field" {
+		fieldrule := new(FieldRule)
+		err = json.Unmarshal(msg, fieldrule)
+		if err != nil {
+			log.Error("Invalid field rule: %v", err)
+			return nil
+		}
+		return fieldrule
+	}
+	log.Error("Unknown router rule type: %s", rule.Type)
+	return nil
+}
+
+func (this *RouterRuleConfig) Rules() []config.Rule {
+	rules := make([]config.Rule, len(this.RuleList))
+	for idx, rawRule := range this.RuleList {
+		rules[idx] = parseRule(rawRule)
+	}
+	return rules
+}
+
+func init() {
+	v2routerconfigjson.RegisterRouterConfig("rules", func() interface{} {
+		return new(RouterRuleConfig)
+	})
+}

app/router/rules/config/json/rules.go

@@ -0,0 +1,19 @@
+package json
+
+import (
+	"github.com/v2ray/v2ray-core/app/point/config"
+	v2net "github.com/v2ray/v2ray-core/common/net"
+)
+
+type Rule struct {
+	Type        string `json:"type"`
+	OutboundTag string `json:"outboundTag"`
+}
+
+func (this *Rule) Tag() config.DetourTag {
+	return config.DetourTag(this.OutboundTag)
+}
+
+func (this *Rule) Apply(dest v2net.Destination) bool {
+	return false
+}

app/router/rules/config/router.go

@@ -0,0 +1,5 @@
+package config
+
+type RouterRuleConfig interface {
+	Rules() []Rule
+}

app/router/rules/config/rules.go

@@ -0,0 +1,11 @@
+package config
+
+import (
+	"github.com/v2ray/v2ray-core/app/point/config"
+	v2net "github.com/v2ray/v2ray-core/common/net"
+)
+
+type Rule interface {
+	Tag() config.DetourTag
+	Apply(dest v2net.Destination) bool
+}

app/router/rules/router.go

@@ -1 +1,51 @@
 package rules
+
+import (
+	"errors"
+
+	pointconfig "github.com/v2ray/v2ray-core/app/point/config"
+	"github.com/v2ray/v2ray-core/app/router"
+	"github.com/v2ray/v2ray-core/app/router/rules/config"
+	"github.com/v2ray/v2ray-core/app/router/rules/config/json"
+	v2net "github.com/v2ray/v2ray-core/common/net"
+)
+
+var (
+	InvalidRule      = errors.New("Invalid Rule")
+	NoRuleApplicable = errors.New("No rule applicable")
+
+	EmptyTag = pointconfig.DetourTag("")
+)
+
+type Router struct {
+	rules []config.Rule
+}
+
+func (this *Router) TakeDetour(dest v2net.Destination) (pointconfig.DetourTag, error) {
+	for _, rule := range this.rules {
+		if rule.Apply(dest) {
+			return rule.Tag(), nil
+		}
+	}
+	return EmptyTag, NoRuleApplicable
+}
+
+type RouterFactory struct {
+}
+
+func (this *RouterFactory) Create(rawConfig interface{}) (router.Router, error) {
+	config := rawConfig.(*json.RouterRuleConfig)
+	rules := config.Rules()
+	for _, rule := range rules {
+		if rule == nil {
+			return nil, InvalidRule
+		}
+	}
+	return &Router{
+		rules: rules,
+	}, nil
+}
+
+func init() {
+	router.RegisterRouter("rules", &RouterFactory{})
+}

common/collect/timed_queue.go

@@ -22,9 +22,7 @@ func (queue timedQueueImpl) Less(i, j int) bool {
 }
 
 func (queue timedQueueImpl) Swap(i, j int) {
-	tmp := queue[i]
-	queue[i] = queue[j]
-	queue[j] = tmp
+	queue[i], queue[j] = queue[j], queue[i]
 }
 
 func (queue *timedQueueImpl) Push(value interface{}) {

common/net/portrange.go

@@ -0,0 +1,6 @@
+package net
+
+type PortRange interface {
+	From() uint16
+	To() uint16
+}

common/net/testing/portrange.go

@@ -0,0 +1,14 @@
+package testing
+
+type PortRange struct {
+	FromValue uint16
+	ToValue   uint16
+}
+
+func (this *PortRange) From() uint16 {
+	return this.FromValue
+}
+
+func (this *PortRange) To() uint16 {
+	return this.ToValue
+}

core.go

@@ -8,7 +8,7 @@ import (
 )
 
 var (
-	version  = "0.11"
+	version  = "0.14"
 	build    = "Custom"
 	codename = "Post Apocalypse"
 	intro    = "A stable and unbreakable connection for everyone."

release/config/vpoint_vmess_freedom.json

@@ -21,5 +21,40 @@
   "outbound": {
     "protocol": "freedom",
     "settings": {}
+  },
+  "outboundDetour": [
+    {
+      "protocol": "blackhole",
+      "settings": {},
+      "tag": "blocked"
+    }
+  ],
+  "routing": {
+    "strategy": "rules",
+    "settings": {
+      "rules": [
+        {
+          "type": "field",
+          "ip": [
+            "0.0.0.0/8",
+            "10.0.0.0/8",
+            "100.64.0.0/10",
+            "127.0.0.0/8",
+            "169.254.0.0/16",
+            "172.16.0.0/12",
+            "192.0.0.0/24",
+            "192.0.2.0/24",
+            "192.168.0.0/16",
+            "198.18.0.0/15",
+            "198.51.100.0/24",
+            "203.0.113.0/24",
+            "::1/128",
+            "fc00::/7",
+            "fe80::/10"
+          ],
+          "outboundTag": "blocked"
+        }
+      ]
+    }
   }
 }

release/server/main.go

@@ -9,9 +9,14 @@ import (
 	"github.com/v2ray/v2ray-core"
 	"github.com/v2ray/v2ray-core/app/point"
 	jsonconf "github.com/v2ray/v2ray-core/app/point/config/json"
+	_ "github.com/v2ray/v2ray-core/app/router/config/json"
+	_ "github.com/v2ray/v2ray-core/app/router/rules"
+	_ "github.com/v2ray/v2ray-core/app/router/rules/config/json"
 	"github.com/v2ray/v2ray-core/common/log"
 
 	// The following are neccesary as they register handlers in their init functions.
+	_ "github.com/v2ray/v2ray-core/proxy/blackhole"
+	_ "github.com/v2ray/v2ray-core/proxy/blackhole/config/json"
 	_ "github.com/v2ray/v2ray-core/proxy/dokodemo"
 	_ "github.com/v2ray/v2ray-core/proxy/dokodemo/config/json"
 	_ "github.com/v2ray/v2ray-core/proxy/freedom"