rename IP to CIDR in router

app/dns/config.pb.go

@@ -31,8 +31,11 @@ var _ = math.Inf
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
 type Config struct {
-	NameServers []*v2ray_core_common_net2.Endpoint           `protobuf:"bytes,1,rep,name=NameServers" json:"NameServers,omitempty"`
-	Hosts       map[string]*v2ray_core_common_net.IPOrDomain `protobuf:"bytes,2,rep,name=Hosts" json:"Hosts,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	// Nameservers used by this DNS. Only traditional UDP servers are support at the moment.
+	// A special value 'localhost' as a domain address can be set to use DNS on local system.
+	NameServers []*v2ray_core_common_net2.Endpoint `protobuf:"bytes,1,rep,name=NameServers" json:"NameServers,omitempty"`
+	// Static hosts. Domain to IP.
+	Hosts map[string]*v2ray_core_common_net.IPOrDomain `protobuf:"bytes,2,rep,name=Hosts" json:"Hosts,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
 }
 
 func (m *Config) Reset()                    { *m = Config{} }

app/router/config.go

@@ -35,19 +35,18 @@ func (this *RoutingRule) BuildCondition() (Condition, error) {
 		conds.Add(anyCond)
 	}
 
-	if len(this.Ip) > 0 {
-		ipv4Net := make(map[uint32]byte)
+	if len(this.Cidr) > 0 {
+		ipv4Net := v2net.NewIPNet()
 		ipv6Cond := NewAnyCondition()
 		hasIpv6 := false
 
-		for _, ip := range this.Ip {
+		for _, ip := range this.Cidr {
 			switch len(ip.Ip) {
 			case net.IPv4len:
-				k := (uint32(ip.Ip[0]) << 24) + (uint32(ip.Ip[1]) << 16) + (uint32(ip.Ip[2]) << 8) + uint32(ip.Ip[3])
-				ipv4Net[k] = byte(32 - ip.UnmatchingBits)
+				ipv4Net.AddIP(ip.Ip, byte(ip.Prefix))
 			case net.IPv6len:
 				hasIpv6 = true
-				matcher, err := NewCIDRMatcher(ip.Ip, uint32(32)-ip.UnmatchingBits)
+				matcher, err := NewCIDRMatcher(ip.Ip, ip.Prefix)
 				if err != nil {
 					return nil, err
 				}
@@ -57,13 +56,13 @@ func (this *RoutingRule) BuildCondition() (Condition, error) {
 			}
 		}
 
-		if len(ipv4Net) > 0 && hasIpv6 {
+		if !ipv4Net.IsEmpty() && hasIpv6 {
 			cond := NewAnyCondition()
-			cond.Add(NewIPv4Matcher(v2net.NewIPNetInitialValue(ipv4Net)))
+			cond.Add(NewIPv4Matcher(ipv4Net))
 			cond.Add(ipv6Cond)
 			conds.Add(cond)
-		} else if len(ipv4Net) > 0 {
-			conds.Add(NewIPv4Matcher(v2net.NewIPNetInitialValue(ipv4Net)))
+		} else if !ipv4Net.IsEmpty() {
+			conds.Add(NewIPv4Matcher(ipv4Net))
 		} else if hasIpv6 {
 			conds.Add(ipv6Cond)
 		}

app/router/config.pb.go

@@ -10,7 +10,7 @@ It is generated from these files:
 
 It has these top-level messages:
 	Domain
-	IP
+	CIDR
 	RoutingRule
 	Config
 */
@@ -60,8 +60,11 @@ func (Domain_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []
 type Config_DomainStrategy int32
 
 const (
-	Config_AsIs         Config_DomainStrategy = 0
-	Config_UseIp        Config_DomainStrategy = 1
+	// Use domain as is.
+	Config_AsIs Config_DomainStrategy = 0
+	// Always resolve IP for domains.
+	Config_UseIp Config_DomainStrategy = 1
+	// Resolve to IP if the domain doesn't match any rules.
 	Config_IpIfNonMatch Config_DomainStrategy = 2
 )
 
@@ -94,25 +97,23 @@ func (m *Domain) String() string            { return proto.CompactTextString(m)
 func (*Domain) ProtoMessage()               {}
 func (*Domain) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 
-// IP for routing decision.
-type IP struct {
+// IP for routing decision, in CIDR form.
+type CIDR struct {
 	// IP address, should be either 4 or 16 bytes.
 	Ip []byte `protobuf:"bytes,1,opt,name=ip,proto3" json:"ip,omitempty"`
-	// Number of right-most bits in IP matching that is allowed.
-	// Single IP address like 127.0.0.1 should use unmatching_bits = 0.
-	// CIDR 10.0.0.0/8 should use unmatching_bits = 32-8 = 24.
-	UnmatchingBits uint32 `protobuf:"varint,2,opt,name=unmatching_bits,json=unmatchingBits" json:"unmatching_bits,omitempty"`
+	// Number of leading ones in the network mask.
+	Prefix uint32 `protobuf:"varint,2,opt,name=prefix" json:"prefix,omitempty"`
 }
 
-func (m *IP) Reset()                    { *m = IP{} }
-func (m *IP) String() string            { return proto.CompactTextString(m) }
-func (*IP) ProtoMessage()               {}
-func (*IP) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+func (m *CIDR) Reset()                    { *m = CIDR{} }
+func (m *CIDR) String() string            { return proto.CompactTextString(m) }
+func (*CIDR) ProtoMessage()               {}
+func (*CIDR) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
 
 type RoutingRule struct {
 	Tag         string                              `protobuf:"bytes,1,opt,name=tag" json:"tag,omitempty"`
 	Domain      []*Domain                           `protobuf:"bytes,2,rep,name=domain" json:"domain,omitempty"`
-	Ip          []*IP                               `protobuf:"bytes,3,rep,name=ip" json:"ip,omitempty"`
+	Cidr        []*CIDR                             `protobuf:"bytes,3,rep,name=cidr" json:"cidr,omitempty"`
 	PortRange   *v2ray_core_common_net.PortRange    `protobuf:"bytes,4,opt,name=port_range,json=portRange" json:"port_range,omitempty"`
 	NetworkList *v2ray_core_common_net1.NetworkList `protobuf:"bytes,5,opt,name=network_list,json=networkList" json:"network_list,omitempty"`
 }
@@ -129,9 +130,9 @@ func (m *RoutingRule) GetDomain() []*Domain {
 	return nil
 }
 
-func (m *RoutingRule) GetIp() []*IP {
+func (m *RoutingRule) GetCidr() []*CIDR {
 	if m != nil {
-		return m.Ip
+		return m.Cidr
 	}
 	return nil
 }
@@ -169,7 +170,7 @@ func (m *Config) GetRule() []*RoutingRule {
 
 func init() {
 	proto.RegisterType((*Domain)(nil), "v2ray.core.app.router.Domain")
-	proto.RegisterType((*IP)(nil), "v2ray.core.app.router.IP")
+	proto.RegisterType((*CIDR)(nil), "v2ray.core.app.router.CIDR")
 	proto.RegisterType((*RoutingRule)(nil), "v2ray.core.app.router.RoutingRule")
 	proto.RegisterType((*Config)(nil), "v2ray.core.app.router.Config")
 	proto.RegisterEnum("v2ray.core.app.router.Domain_Type", Domain_Type_name, Domain_Type_value)
@@ -179,34 +180,34 @@ func init() {
 func init() { proto.RegisterFile("v2ray.com/core/app/router/config.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 462 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x7c, 0x92, 0x5f, 0x6b, 0xd5, 0x30,
-	0x18, 0xc6, 0x6d, 0x77, 0x4e, 0xf1, 0xbc, 0x3d, 0x76, 0x25, 0x28, 0x74, 0x43, 0xa1, 0x14, 0x71,
-	0x47, 0x90, 0x54, 0x8e, 0xa8, 0x57, 0x22, 0x1e, 0xf5, 0xa2, 0xa0, 0xa3, 0x44, 0x77, 0xe3, 0xcd,
-	0x21, 0xeb, 0xb2, 0x1a, 0x6c, 0x93, 0x90, 0xa6, 0xd3, 0xf3, 0x11, 0xfc, 0x76, 0x7e, 0x24, 0x69,
-	0xd2, 0xb1, 0x4d, 0x56, 0xef, 0xf2, 0x86, 0xdf, 0xf3, 0xfe, 0x7d, 0xe0, 0xc9, 0xc5, 0x5a, 0xd3,
-	0x1d, 0xae, 0x64, 0x9b, 0x57, 0x52, 0xb3, 0x9c, 0x2a, 0x95, 0x6b, 0xd9, 0x1b, 0xa6, 0xf3, 0x4a,
-	0x8a, 0x73, 0x5e, 0x63, 0xa5, 0xa5, 0x91, 0xe8, 0xc1, 0x25, 0xa7, 0x19, 0xa6, 0x4a, 0x61, 0xc7,
-	0x1c, 0x3e, 0xfe, 0x47, 0x5e, 0xc9, 0xb6, 0x95, 0x22, 0x17, 0xcc, 0xe4, 0x4a, 0x6a, 0xe3, 0xc4,
-	0x87, 0x47, 0xd3, 0x94, 0x60, 0xe6, 0xa7, 0xd4, 0x3f, 0x1c, 0x98, 0x19, 0x08, 0x3e, 0xc8, 0x96,
-	0x72, 0x81, 0x5e, 0xc1, 0xcc, 0xec, 0x14, 0x4b, 0xbc, 0xd4, 0x5b, 0x45, 0xeb, 0x0c, 0xdf, 0x5a,
-	0x1e, 0x3b, 0x18, 0x7f, 0xdd, 0x29, 0x46, 0x2c, 0x8f, 0xee, 0xc3, 0xfc, 0x82, 0x36, 0x3d, 0x4b,
-	0xfc, 0xd4, 0x5b, 0x2d, 0x88, 0x0b, 0xb2, 0x87, 0x30, 0x1b, 0x18, 0xb4, 0x80, 0x79, 0xd9, 0x50,
-	0x2e, 0xe2, 0x3b, 0xc3, 0x93, 0xb0, 0x9a, 0xfd, 0x8a, 0xbd, 0xec, 0x0d, 0xf8, 0x45, 0x89, 0x22,
-	0xf0, 0xb9, 0xb2, 0xf5, 0x96, 0xc4, 0xe7, 0x0a, 0x1d, 0xc1, 0x7e, 0x2f, 0x5a, 0x6a, 0xaa, 0xef,
-	0x5c, 0xd4, 0xdb, 0x53, 0x6e, 0x3a, 0x9b, 0xf3, 0x1e, 0x89, 0xae, 0xbe, 0x37, 0xdc, 0x74, 0xd9,
-	0x6f, 0x1f, 0x42, 0x22, 0x7b, 0xc3, 0x45, 0x4d, 0xfa, 0x86, 0xa1, 0x18, 0xf6, 0x0c, 0xad, 0x6d,
-	0xa6, 0x05, 0x19, 0x9e, 0xe8, 0x25, 0x04, 0x67, 0xb6, 0xd3, 0xc4, 0x4f, 0xf7, 0x56, 0xe1, 0xfa,
-	0xd1, 0x7f, 0xc7, 0x21, 0x23, 0x8c, 0x9e, 0xda, 0x8e, 0xf6, 0xac, 0xe4, 0x60, 0x42, 0x52, 0x94,
-	0xb6, 0xd9, 0xb7, 0x00, 0xc3, 0xbe, 0xb7, 0x9a, 0x8a, 0x9a, 0x25, 0xb3, 0xd4, 0x5b, 0x85, 0xeb,
-	0xf4, 0xba, 0xc4, 0xad, 0x1c, 0x0b, 0x66, 0x70, 0x29, 0xb5, 0x21, 0x03, 0x47, 0x16, 0xea, 0xf2,
-	0x89, 0x3e, 0xc2, 0x72, 0x3c, 0xc5, 0xb6, 0xe1, 0x9d, 0x49, 0xe6, 0x36, 0x45, 0x36, 0x91, 0xe2,
-	0xd8, 0xa1, 0x9f, 0x78, 0x67, 0x48, 0x28, 0xae, 0x82, 0xec, 0x8f, 0x07, 0xc1, 0x7b, 0xeb, 0x1b,
-	0x74, 0x02, 0xfb, 0x6e, 0x8e, 0x6d, 0x67, 0x34, 0x35, 0xac, 0xde, 0x8d, 0xc7, 0x7c, 0x36, 0x31,
-	0x8a, 0xd3, 0x8d, 0x4b, 0xf8, 0x32, 0x6a, 0x48, 0x74, 0x76, 0x23, 0x1e, 0x8c, 0xa1, 0xfb, 0x86,
-	0x8d, 0x9b, 0x9c, 0x32, 0xc6, 0xb5, 0x7b, 0x10, 0xcb, 0x67, 0xaf, 0x21, 0xba, 0x99, 0x19, 0xdd,
-	0x85, 0xd9, 0xbb, 0xae, 0xe8, 0x9c, 0x17, 0x4e, 0x3a, 0x56, 0xa8, 0xd8, 0x43, 0x31, 0x2c, 0x0b,
-	0x55, 0x9c, 0x1f, 0x4b, 0xf1, 0x79, 0xb8, 0x71, 0xec, 0x6f, 0x9e, 0xc3, 0x41, 0x25, 0xdb, 0xdb,
-	0xeb, 0x6c, 0x42, 0xd7, 0x74, 0x39, 0xb8, 0xf7, 0x5b, 0xe0, 0x3e, 0x4f, 0x03, 0x6b, 0xe6, 0x17,
-	0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x93, 0xed, 0x34, 0x36, 0x5c, 0x03, 0x00, 0x00,
+	// 458 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x7c, 0x92, 0xc1, 0x8e, 0xd3, 0x30,
+	0x10, 0x86, 0x49, 0x9a, 0x46, 0x74, 0x52, 0x4a, 0x64, 0x01, 0x0a, 0x0b, 0x48, 0x51, 0x84, 0xa0,
+	0x07, 0xe4, 0xa0, 0x22, 0xe0, 0x88, 0xd8, 0x5d, 0x0e, 0x91, 0x60, 0x55, 0x19, 0xf6, 0xc2, 0xa5,
+	0x32, 0xa9, 0x1b, 0x2c, 0x12, 0xdb, 0x72, 0x9c, 0x65, 0xfb, 0x14, 0xbc, 0x1a, 0x8f, 0x84, 0x62,
+	0x67, 0xc5, 0x2e, 0x6a, 0xb8, 0xcd, 0x58, 0xdf, 0x3f, 0x33, 0x9e, 0xf9, 0xe1, 0xd9, 0xc5, 0x4a,
+	0xd3, 0x3d, 0x2e, 0x65, 0x93, 0x97, 0x52, 0xb3, 0x9c, 0x2a, 0x95, 0x6b, 0xd9, 0x19, 0xa6, 0xf3,
+	0x52, 0x8a, 0x1d, 0xaf, 0xb0, 0xd2, 0xd2, 0x48, 0x74, 0xff, 0x8a, 0xd3, 0x0c, 0x53, 0xa5, 0xb0,
+	0x63, 0x8e, 0x9e, 0xfe, 0x23, 0x2f, 0x65, 0xd3, 0x48, 0x91, 0x0b, 0x66, 0x72, 0x25, 0xb5, 0x71,
+	0xe2, 0xa3, 0xe7, 0xe3, 0x94, 0x60, 0xe6, 0xa7, 0xd4, 0x3f, 0x1c, 0x98, 0x19, 0x08, 0x4f, 0x65,
+	0x43, 0xb9, 0x40, 0x6f, 0x20, 0x30, 0x7b, 0xc5, 0x12, 0x2f, 0xf5, 0x96, 0x8b, 0x55, 0x86, 0x0f,
+	0xb6, 0xc7, 0x0e, 0xc6, 0x5f, 0xf6, 0x8a, 0x11, 0xcb, 0xa3, 0x7b, 0x30, 0xbd, 0xa0, 0x75, 0xc7,
+	0x12, 0x3f, 0xf5, 0x96, 0x33, 0xe2, 0x92, 0xec, 0x31, 0x04, 0x3d, 0x83, 0x66, 0x30, 0x5d, 0xd7,
+	0x94, 0x8b, 0xf8, 0x56, 0x1f, 0x12, 0x56, 0xb1, 0xcb, 0xd8, 0xcb, 0x30, 0x04, 0x27, 0xc5, 0x29,
+	0x41, 0x0b, 0xf0, 0xb9, 0xb2, 0x1d, 0xe7, 0xc4, 0xe7, 0x0a, 0x3d, 0x80, 0x50, 0x69, 0xb6, 0xe3,
+	0x97, 0xb6, 0xd8, 0x1d, 0x32, 0x64, 0xd9, 0x2f, 0x1f, 0x22, 0x22, 0x3b, 0xc3, 0x45, 0x45, 0xba,
+	0x9a, 0xa1, 0x18, 0x26, 0x86, 0x56, 0x56, 0x38, 0x23, 0x7d, 0x88, 0x5e, 0x43, 0xb8, 0xb5, 0xa3,
+	0x25, 0x7e, 0x3a, 0x59, 0x46, 0xab, 0x27, 0xff, 0x9d, 0x9f, 0x0c, 0x30, 0xca, 0x21, 0x28, 0xf9,
+	0x56, 0x27, 0x13, 0x2b, 0x7a, 0x34, 0x22, 0xea, 0x67, 0x25, 0x16, 0x44, 0xef, 0x00, 0xfa, 0x35,
+	0x6f, 0x34, 0x15, 0x15, 0x4b, 0x82, 0xd4, 0x5b, 0x46, 0xab, 0xf4, 0xba, 0xcc, 0x6d, 0x1a, 0x0b,
+	0x66, 0xf0, 0x5a, 0x6a, 0x43, 0x7a, 0x8e, 0xcc, 0xd4, 0x55, 0x88, 0x3e, 0xc0, 0x7c, 0xb8, 0xc0,
+	0xa6, 0xe6, 0xad, 0x49, 0xa6, 0xb6, 0x44, 0x36, 0x52, 0xe2, 0xcc, 0xa1, 0x1f, 0x79, 0x6b, 0x48,
+	0x24, 0xfe, 0x26, 0xd9, 0x6f, 0x0f, 0xc2, 0x13, 0x6b, 0x17, 0x74, 0x0e, 0x77, 0xdd, 0x6f, 0x36,
+	0xad, 0xd1, 0xd4, 0xb0, 0x6a, 0x3f, 0xdc, 0xf0, 0xc5, 0xd8, 0x77, 0x9c, 0xcd, 0xdc, 0x2a, 0x3e,
+	0x0f, 0x1a, 0xb2, 0xd8, 0xde, 0xc8, 0x7b, 0x3f, 0xe8, 0xae, 0x66, 0xc3, 0x3e, 0xc7, 0xfc, 0x70,
+	0xed, 0x2a, 0xc4, 0xf2, 0xd9, 0x5b, 0x58, 0xdc, 0xac, 0x8c, 0x6e, 0x43, 0xf0, 0xbe, 0x2d, 0x5a,
+	0x67, 0x81, 0xf3, 0x96, 0x15, 0x2a, 0xf6, 0x50, 0x0c, 0xf3, 0x42, 0x15, 0xbb, 0x33, 0x29, 0x3e,
+	0x51, 0x53, 0x7e, 0x8f, 0xfd, 0xe3, 0x97, 0xf0, 0xb0, 0x94, 0xcd, 0xe1, 0x3e, 0xc7, 0x91, 0x1b,
+	0x7a, 0xdd, 0x9b, 0xf6, 0x6b, 0xe8, 0x1e, 0xbf, 0x85, 0xd6, 0xc3, 0xaf, 0xfe, 0x04, 0x00, 0x00,
+	0xff, 0xff, 0xa7, 0x28, 0xf6, 0x96, 0x53, 0x03, 0x00, 0x00,
 }

app/router/config.proto

@@ -25,21 +25,19 @@ message Domain {
   string value = 2;
 }
 
-// IP for routing decision.
-message IP {
+// IP for routing decision, in CIDR form.
+message CIDR {
   // IP address, should be either 4 or 16 bytes.
   bytes ip = 1;
 
-  // Number of right-most bits in IP matching that is allowed.
-  // Single IP address like 127.0.0.1 should use unmatching_bits = 0.
-  // CIDR 10.0.0.0/8 should use unmatching_bits = 32-8 = 24.
-  uint32 unmatching_bits = 2;
+  // Number of leading ones in the network mask.
+  uint32 prefix = 2;
 }
 
 message RoutingRule {
   string tag = 1;
   repeated Domain domain = 2;
-  repeated IP ip = 3;
+  repeated CIDR cidr = 3;
   v2ray.core.common.net.PortRange port_range = 4;
   v2ray.core.common.net.NetworkList network_list = 5;
 }

common/loader/type.pb.go

@@ -28,8 +28,11 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
+// Serialized proto message along with its type name.
 type TypedSettings struct {
-	Type     string `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"`
+	// The name of the message type, retrieved from protobuf API.
+	Type string `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"`
+	// Serialized proto message.
 	Settings []byte `protobuf:"bytes,2,opt,name=settings,proto3" json:"settings,omitempty"`
 }
 

common/net/ipnet.go

@@ -13,12 +13,8 @@ type IPNet struct {
 }
 
 func NewIPNet() *IPNet {
-	return NewIPNetInitialValue(make(map[uint32]byte, 1024))
-}
-
-func NewIPNetInitialValue(data map[uint32]byte) *IPNet {
 	return &IPNet{
-		cache: data,
+		cache: make(map[uint32]byte, 1024),
 	}
 }
 
@@ -45,11 +41,15 @@ func (this *IPNet) Add(ipNet *net.IPNet) {
 		// For now, we don't support IPv6
 		return
 	}
-	value := ipToUint32(ipv4)
 	mask := ipMaskToByte(ipNet.Mask)
-	existing, found := this.cache[value]
+	this.AddIP(ipv4, mask)
+}
+
+func (this *IPNet) AddIP(ip []byte, mask byte) {
+	k := ipToUint32(ip)
+	existing, found := this.cache[k]
 	if !found || existing > mask {
-		this.cache[value] = mask
+		this.cache[k] = mask
 	}
 }
 
@@ -80,12 +80,8 @@ func (this *IPNet) Contains(ip net.IP) bool {
 	return false
 }
 
-func (this *IPNet) Serialize() []uint32 {
-	content := make([]uint32, 0, 2*len(this.cache))
-	for key, value := range this.cache {
-		content = append(content, uint32(key), uint32(value))
-	}
-	return content
+func (this *IPNet) IsEmpty() bool {
+	return len(this.cache) == 0
 }
 
 func init() {

common/net/network.pb.go

@@ -16,8 +16,10 @@ var _ = math.Inf
 type Network int32
 
 const (
-	Network_Unknown   Network = 0
-	Network_RawTCP    Network = 1
+	Network_Unknown Network = 0
+	// Native TCP provided by system.
+	Network_RawTCP Network = 1
+	// V2Ray specific TCP.
 	Network_TCP       Network = 2
 	Network_UDP       Network = 3
 	Network_KCP       Network = 4

common/protocol/user.pb.go

@@ -15,8 +15,9 @@ var _ = fmt.Errorf
 var _ = math.Inf
 
 type User struct {
-	Level   uint32                                  `protobuf:"varint,1,opt,name=level" json:"level,omitempty"`
-	Email   string                                  `protobuf:"bytes,2,opt,name=email" json:"email,omitempty"`
+	Level uint32 `protobuf:"varint,1,opt,name=level" json:"level,omitempty"`
+	Email string `protobuf:"bytes,2,opt,name=email" json:"email,omitempty"`
+	// Protocol specific account information.
 	Account *v2ray_core_common_loader.TypedSettings `protobuf:"bytes,3,opt,name=account" json:"account,omitempty"`
 }
 

config.pb.go

@@ -39,6 +39,7 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
+// Configuration serialization format.
 type ConfigFormat int32
 
 const (
@@ -108,8 +109,10 @@ func (*AllocationStrategyRefresh) Descriptor() ([]byte, []int) { return fileDesc
 type AllocationStrategy struct {
 	Type AllocationStrategy_Type `protobuf:"varint,1,opt,name=type,enum=v2ray.core.AllocationStrategy_Type" json:"type,omitempty"`
 	// Number of handlers (ports) running in parallel.
+	// Default value is 3 if unset.
 	Concurrency *AllocationStrategyConcurrency `protobuf:"bytes,2,opt,name=concurrency" json:"concurrency,omitempty"`
 	// Number of minutes before a handler is regenerated.
+	// Default value is 5 if unset.
 	Refresh *AllocationStrategyRefresh `protobuf:"bytes,3,opt,name=refresh" json:"refresh,omitempty"`
 }
 
@@ -134,9 +137,13 @@ func (m *AllocationStrategy) GetRefresh() *AllocationStrategyRefresh {
 
 // Config for an inbound connection handler.
 type InboundConnectionConfig struct {
-	Settings               *v2ray_core_common_loader.TypedSettings     `protobuf:"bytes,1,opt,name=settings" json:"settings,omitempty"`
-	PortRange              *v2ray_core_common_net.PortRange            `protobuf:"bytes,2,opt,name=port_range,json=portRange" json:"port_range,omitempty"`
-	ListenOn               *v2ray_core_common_net1.IPOrDomain          `protobuf:"bytes,3,opt,name=listen_on,json=listenOn" json:"listen_on,omitempty"`
+	// Protocol specific settings. Must be one of the supported protocols.
+	Settings *v2ray_core_common_loader.TypedSettings `protobuf:"bytes,1,opt,name=settings" json:"settings,omitempty"`
+	// Range of port number to run on. Both inclusive.
+	PortRange *v2ray_core_common_net.PortRange `protobuf:"bytes,2,opt,name=port_range,json=portRange" json:"port_range,omitempty"`
+	// IP address to listen on. 0.0.0.0 if unset.
+	ListenOn *v2ray_core_common_net1.IPOrDomain `protobuf:"bytes,3,opt,name=listen_on,json=listenOn" json:"listen_on,omitempty"`
+	// Tag of this handler.
 	Tag                    string                                      `protobuf:"bytes,4,opt,name=tag" json:"tag,omitempty"`
 	AllocationStrategy     *AllocationStrategy                         `protobuf:"bytes,5,opt,name=allocation_strategy,json=allocationStrategy" json:"allocation_strategy,omitempty"`
 	StreamSettings         *v2ray_core_transport_internet.StreamConfig `protobuf:"bytes,6,opt,name=stream_settings,json=streamSettings" json:"stream_settings,omitempty"`
@@ -183,8 +190,10 @@ func (m *InboundConnectionConfig) GetStreamSettings() *v2ray_core_transport_inte
 	return nil
 }
 
+// Config for an outbound connection handler.
 type OutboundConnectionConfig struct {
-	Settings       *v2ray_core_common_loader.TypedSettings     `protobuf:"bytes,1,opt,name=settings" json:"settings,omitempty"`
+	Settings *v2ray_core_common_loader.TypedSettings `protobuf:"bytes,1,opt,name=settings" json:"settings,omitempty"`
+	// IP address to send data through. 0.0.0.0 if unset.
 	SendThrough    *v2ray_core_common_net1.IPOrDomain          `protobuf:"bytes,2,opt,name=send_through,json=sendThrough" json:"send_through,omitempty"`
 	StreamSettings *v2ray_core_transport_internet.StreamConfig `protobuf:"bytes,3,opt,name=stream_settings,json=streamSettings" json:"stream_settings,omitempty"`
 	Tag            string                                      `protobuf:"bytes,4,opt,name=tag" json:"tag,omitempty"`
@@ -217,9 +226,12 @@ func (m *OutboundConnectionConfig) GetStreamSettings() *v2ray_core_transport_int
 }
 
 type Config struct {
-	Inbound   []*InboundConnectionConfig                `protobuf:"bytes,1,rep,name=inbound" json:"inbound,omitempty"`
-	Outbound  []*OutboundConnectionConfig               `protobuf:"bytes,2,rep,name=outbound" json:"outbound,omitempty"`
-	Log       *v2ray_core_common_log.Config             `protobuf:"bytes,3,opt,name=log" json:"log,omitempty"`
+	// Inbound handler configurations. Must have at least one item.
+	Inbound []*InboundConnectionConfig `protobuf:"bytes,1,rep,name=inbound" json:"inbound,omitempty"`
+	// Outbound handler configurations. Must have at least one item. The first item is used as default for routing.
+	Outbound []*OutboundConnectionConfig   `protobuf:"bytes,2,rep,name=outbound" json:"outbound,omitempty"`
+	Log      *v2ray_core_common_log.Config `protobuf:"bytes,3,opt,name=log" json:"log,omitempty"`
+	// App configuration. Must be one in the app directory.
 	App       []*v2ray_core_common_loader.TypedSettings `protobuf:"bytes,4,rep,name=app" json:"app,omitempty"`
 	Transport *v2ray_core_transport.Config              `protobuf:"bytes,5,opt,name=transport" json:"transport,omitempty"`
 }

tools/conf/router.go

@@ -50,7 +50,7 @@ type RouterRule struct {
 	OutboundTag string `json:"outboundTag"`
 }
 
-func parseIP(s string) *router.IP {
+func parseIP(s string) *router.CIDR {
 	var addr, mask string
 	i := strings.Index(s, "/")
 	if i < 0 {
@@ -74,9 +74,9 @@ func parseIP(s string) *router.IP {
 			log.Warning("Router: invalid network mask: ", bits)
 			return nil
 		}
-		return &router.IP{
-			Ip:             []byte(ip.IP()),
-			UnmatchingBits: 32 - bits,
+		return &router.CIDR{
+			Ip:     []byte(ip.IP()),
+			Prefix: bits,
 		}
 	case v2net.AddressFamilyIPv6:
 		bits := uint32(128)
@@ -91,9 +91,9 @@ func parseIP(s string) *router.IP {
 			log.Warning("Router: invalid network mask: ", bits)
 			return nil
 		}
-		return &router.IP{
-			Ip:             []byte(ip.IP()),
-			UnmatchingBits: 128 - bits,
+		return &router.CIDR{
+			Ip:     []byte(ip.IP()),
+			Prefix: bits,
 		}
 	default:
 		log.Warning("Router: unsupported address: ", s)
@@ -136,7 +136,7 @@ func parseFieldRule(msg json.RawMessage) (*router.RoutingRule, error) {
 		for _, ip := range *rawFieldRule.IP {
 			ipRule := parseIP(ip)
 			if ipRule != nil {
-				rule.Ip = append(rule.Ip, ipRule)
+				rule.Cidr = append(rule.Cidr, ipRule)
 			}
 		}
 	}
@@ -200,8 +200,8 @@ func parseChinaIPRule(data []byte) (*router.RoutingRule, error) {
 		return nil, err
 	}
 	return &router.RoutingRule{
-		Tag: rawRule.OutboundTag,
-		Ip:  chinaIPs.Ips,
+		Tag:  rawRule.OutboundTag,
+		Cidr: chinaIPs.Ips,
 	}, nil
 }
 

tools/geoip/geoip.pb.go

@@ -30,7 +30,7 @@ var _ = math.Inf
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
 type CountryIPRange struct {
-	Ips []*v2ray_core_app_router.IP `protobuf:"bytes,1,rep,name=ips" json:"ips,omitempty"`
+	Ips []*v2ray_core_app_router.CIDR `protobuf:"bytes,1,rep,name=ips" json:"ips,omitempty"`
 }
 
 func (m *CountryIPRange) Reset()                    { *m = CountryIPRange{} }
@@ -38,7 +38,7 @@ func (m *CountryIPRange) String() string            { return proto.CompactTextSt
 func (*CountryIPRange) ProtoMessage()               {}
 func (*CountryIPRange) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 
-func (m *CountryIPRange) GetIps() []*v2ray_core_app_router.IP {
+func (m *CountryIPRange) GetIps() []*v2ray_core_app_router.CIDR {
 	if m != nil {
 		return m.Ips
 	}
@@ -52,15 +52,15 @@ func init() {
 func init() { proto.RegisterFile("v2ray.com/core/tools/geoip/geoip.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 153 bytes of a gzipped FileDescriptorProto
+	// 155 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0x52, 0x2b, 0x33, 0x2a, 0x4a,
 	0xac, 0xd4, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0x2f, 0x4a, 0xd5, 0x2f, 0xc9, 0xcf, 0xcf, 0x29,
 	0xd6, 0x4f, 0x4f, 0xcd, 0xcf, 0x2c, 0x80, 0x90, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0x62,
 	0x30, 0x75, 0x45, 0xa9, 0x7a, 0x60, 0x35, 0x7a, 0x60, 0x59, 0x29, 0x74, 0xfd, 0x89, 0x05, 0x05,
 	0xfa, 0x45, 0xf9, 0xa5, 0x25, 0xa9, 0x45, 0xfa, 0xc9, 0xf9, 0x79, 0x69, 0x99, 0xe9, 0x10, 0xfd,
-	0x4a, 0xb6, 0x5c, 0x7c, 0xce, 0xf9, 0xa5, 0x79, 0x25, 0x45, 0x95, 0x9e, 0x01, 0x41, 0x89, 0x79,
-	0xe9, 0xa9, 0x42, 0xda, 0x5c, 0xcc, 0x99, 0x05, 0xc5, 0x12, 0x8c, 0x0a, 0xcc, 0x1a, 0xdc, 0x46,
-	0x92, 0x7a, 0x48, 0xe6, 0x27, 0x16, 0x14, 0xe8, 0x41, 0xcc, 0xd0, 0xf3, 0x0c, 0x08, 0x02, 0xa9,
-	0x72, 0x62, 0x8f, 0x62, 0x05, 0xdb, 0x97, 0xc4, 0x06, 0x36, 0xce, 0x18, 0x10, 0x00, 0x00, 0xff,
-	0xff, 0x60, 0x87, 0xf6, 0x5e, 0xb8, 0x00, 0x00, 0x00,
+	0x4a, 0xf6, 0x5c, 0x7c, 0xce, 0xf9, 0xa5, 0x79, 0x25, 0x45, 0x95, 0x9e, 0x01, 0x41, 0x89, 0x79,
+	0xe9, 0xa9, 0x42, 0xba, 0x5c, 0xcc, 0x99, 0x05, 0xc5, 0x12, 0x8c, 0x0a, 0xcc, 0x1a, 0xdc, 0x46,
+	0xd2, 0x7a, 0x48, 0xe6, 0x27, 0x16, 0x14, 0xe8, 0x41, 0xcc, 0xd0, 0x73, 0xf6, 0x74, 0x09, 0x0a,
+	0x02, 0xa9, 0x73, 0x62, 0x8f, 0x62, 0x05, 0xdb, 0x98, 0xc4, 0x06, 0x36, 0xd0, 0x18, 0x10, 0x00,
+	0x00, 0xff, 0xff, 0xf8, 0x02, 0xe8, 0xc0, 0xba, 0x00, 0x00, 0x00,
 }

tools/geoip/geoip.proto

@@ -6,5 +6,5 @@ option go_package = "geoip";
 import "v2ray.com/core/app/router/config.proto";
 
 message CountryIPRange {
-  repeated v2ray.core.app.router.IP ips = 1;
+  repeated v2ray.core.app.router.CIDR ips = 1;
 }

tools/geoip/geoip_gen.go

@@ -35,7 +35,7 @@ func main() {
 	scanner := bufio.NewScanner(resp.Body)
 
 	ips := &geoip.CountryIPRange{
-		Ips: make([]*router.IP, 0, 8192),
+		Ips: make([]*router.CIDR, 0, 8192),
 	}
 	for scanner.Scan() {
 		line := scanner.Text()
@@ -57,9 +57,9 @@ func main() {
 		if len(ipBytes) == 0 {
 			panic("Invalid IP " + ip)
 		}
-		ips.Ips = append(ips.Ips, &router.IP{
-			Ip:             []byte(ipBytes)[12:16],
-			UnmatchingBits: mask,
+		ips.Ips = append(ips.Ips, &router.CIDR{
+			Ip:     []byte(ipBytes)[12:16],
+			Prefix: 32 - mask,
 		})
 	}
 

transport/config.pb.go

@@ -29,6 +29,7 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
+// Global transport settings. This affects all type of connections that go through V2Ray.
 type Config struct {
 	NetworkSettings []*v2ray_core_transport_internet.NetworkSettings `protobuf:"bytes,1,rep,name=network_settings,json=networkSettings" json:"network_settings,omitempty"`
 }

transport/internet/config.pb.go

@@ -2,6 +2,16 @@
 // source: v2ray.com/core/transport/internet/config.proto
 // DO NOT EDIT!
 
+/*
+Package internet is a generated protocol buffer package.
+
+It is generated from these files:
+	v2ray.com/core/transport/internet/config.proto
+
+It has these top-level messages:
+	NetworkSettings
+	StreamConfig
+*/
 package internet
 
 import proto "github.com/golang/protobuf/proto"
@@ -15,15 +25,23 @@ var _ = proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
 type NetworkSettings struct {
-	Network  v2ray_core_common_net.Network           `protobuf:"varint,1,opt,name=network,enum=v2ray.core.common.net.Network" json:"network,omitempty"`
+	// Type of network that this settings supports.
+	Network v2ray_core_common_net.Network `protobuf:"varint,1,opt,name=network,enum=v2ray.core.common.net.Network" json:"network,omitempty"`
+	// Specific settings.
 	Settings *v2ray_core_common_loader.TypedSettings `protobuf:"bytes,2,opt,name=settings" json:"settings,omitempty"`
 }
 
 func (m *NetworkSettings) Reset()                    { *m = NetworkSettings{} }
 func (m *NetworkSettings) String() string            { return proto.CompactTextString(m) }
 func (*NetworkSettings) ProtoMessage()               {}
-func (*NetworkSettings) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
+func (*NetworkSettings) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 
 func (m *NetworkSettings) GetSettings() *v2ray_core_common_loader.TypedSettings {
 	if m != nil {
@@ -33,8 +51,10 @@ func (m *NetworkSettings) GetSettings() *v2ray_core_common_loader.TypedSettings
 }
 
 type StreamConfig struct {
-	Network          v2ray_core_common_net.Network             `protobuf:"varint,1,opt,name=network,enum=v2ray.core.common.net.Network" json:"network,omitempty"`
-	NetworkSettings  []*NetworkSettings                        `protobuf:"bytes,2,rep,name=network_settings,json=networkSettings" json:"network_settings,omitempty"`
+	// Effective network.
+	Network         v2ray_core_common_net.Network `protobuf:"varint,1,opt,name=network,enum=v2ray.core.common.net.Network" json:"network,omitempty"`
+	NetworkSettings []*NetworkSettings            `protobuf:"bytes,2,rep,name=network_settings,json=networkSettings" json:"network_settings,omitempty"`
+	// Type of security. Must be a message name of the settings proto.
 	SecurityType     string                                    `protobuf:"bytes,3,opt,name=security_type,json=securityType" json:"security_type,omitempty"`
 	SecuritySettings []*v2ray_core_common_loader.TypedSettings `protobuf:"bytes,4,rep,name=security_settings,json=securitySettings" json:"security_settings,omitempty"`
 }
@@ -42,7 +62,7 @@ type StreamConfig struct {
 func (m *StreamConfig) Reset()                    { *m = StreamConfig{} }
 func (m *StreamConfig) String() string            { return proto.CompactTextString(m) }
 func (*StreamConfig) ProtoMessage()               {}
-func (*StreamConfig) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
+func (*StreamConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
 
 func (m *StreamConfig) GetNetworkSettings() []*NetworkSettings {
 	if m != nil {
@@ -63,9 +83,9 @@ func init() {
 	proto.RegisterType((*StreamConfig)(nil), "v2ray.core.transport.internet.StreamConfig")
 }
 
-func init() { proto.RegisterFile("v2ray.com/core/transport/internet/config.proto", fileDescriptor1) }
+func init() { proto.RegisterFile("v2ray.com/core/transport/internet/config.proto", fileDescriptor0) }
 
-var fileDescriptor1 = []byte{
+var fileDescriptor0 = []byte{
 	// 296 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x91, 0x4f, 0x4b, 0xc3, 0x40,
 	0x10, 0xc5, 0x49, 0x2b, 0x5a, 0xb7, 0xd5, 0xd6, 0x9c, 0x82, 0xa0, 0xc4, 0x7a, 0x68, 0x2e, 0xce,

transport/internet/tls/config.pb.go

@@ -30,8 +30,10 @@ var _ = math.Inf
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
 type Certificate struct {
+	// TLS certificate in x509 format.
 	Certificate []byte `protobuf:"bytes,1,opt,name=Certificate,proto3" json:"Certificate,omitempty"`
-	Key         []byte `protobuf:"bytes,2,opt,name=Key,proto3" json:"Key,omitempty"`
+	// TLS key in x509 format.
+	Key []byte `protobuf:"bytes,2,opt,name=Key,proto3" json:"Key,omitempty"`
 }
 
 func (m *Certificate) Reset()                    { *m = Certificate{} }
@@ -40,8 +42,10 @@ func (*Certificate) ProtoMessage()               {}
 func (*Certificate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 
 type Config struct {
-	AllowInsecure bool           `protobuf:"varint,1,opt,name=allow_insecure,json=allowInsecure" json:"allow_insecure,omitempty"`
-	Certificate   []*Certificate `protobuf:"bytes,2,rep,name=certificate" json:"certificate,omitempty"`
+	// Whether or not to allow self-signed certificates.
+	AllowInsecure bool `protobuf:"varint,1,opt,name=allow_insecure,json=allowInsecure" json:"allow_insecure,omitempty"`
+	// List of certificates to be served on server.
+	Certificate []*Certificate `protobuf:"bytes,2,rep,name=certificate" json:"certificate,omitempty"`
 }
 
 func (m *Config) Reset()                    { *m = Config{} }

transport/internet/ws/config.pb.go

@@ -39,8 +39,10 @@ func (*ConnectionReuse) ProtoMessage()               {}
 func (*ConnectionReuse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 
 type Config struct {
+	// Whether or not to reuse WebSocket connections.
 	ConnectionReuse *ConnectionReuse `protobuf:"bytes,1,opt,name=connection_reuse,json=connectionReuse" json:"connection_reuse,omitempty"`
-	Path            string           `protobuf:"bytes,2,opt,name=path" json:"path,omitempty"`
+	// URL path to the WebSocket service. Empty value means root(/).
+	Path string `protobuf:"bytes,2,opt,name=path" json:"path,omitempty"`
 }
 
 func (m *Config) Reset()                    { *m = Config{} }