protobuf for net

common/net/address.go

@@ -186,3 +186,13 @@ func (this *domainAddress) Equals(another Address) bool {
 	}
 	return this.Domain() == anotherDomain.Domain()
 }
+
+func (this *AddressPB) AsAddress() Address {
+	switch addr := this.Address.(type) {
+	case *AddressPB_Ip:
+		return IPAddress(addr.Ip)
+	case *AddressPB_Domain:
+		return DomainAddress(addr.Domain)
+	}
+	panic("Common|Net: Invalid AddressPB.")
+}

common/net/address.pb.go

@@ -0,0 +1,163 @@
+// Code generated by protoc-gen-go.
+// source: address.proto
+// DO NOT EDIT!
+
+/*
+Package net is a generated protocol buffer package.
+
+It is generated from these files:
+	address.proto
+	port.proto
+
+It has these top-level messages:
+	AddressPB
+	PortRange
+*/
+package net
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+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 AddressPB struct {
+	// Types that are valid to be assigned to Address:
+	//	*AddressPB_Ip
+	//	*AddressPB_Domain
+	Address isAddressPB_Address `protobuf_oneof:"address"`
+}
+
+func (m *AddressPB) Reset()                    { *m = AddressPB{} }
+func (m *AddressPB) String() string            { return proto.CompactTextString(m) }
+func (*AddressPB) ProtoMessage()               {}
+func (*AddressPB) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+type isAddressPB_Address interface {
+	isAddressPB_Address()
+}
+
+type AddressPB_Ip struct {
+	Ip []byte `protobuf:"bytes,1,opt,name=ip,proto3,oneof"`
+}
+type AddressPB_Domain struct {
+	Domain string `protobuf:"bytes,2,opt,name=domain,oneof"`
+}
+
+func (*AddressPB_Ip) isAddressPB_Address()     {}
+func (*AddressPB_Domain) isAddressPB_Address() {}
+
+func (m *AddressPB) GetAddress() isAddressPB_Address {
+	if m != nil {
+		return m.Address
+	}
+	return nil
+}
+
+func (m *AddressPB) GetIp() []byte {
+	if x, ok := m.GetAddress().(*AddressPB_Ip); ok {
+		return x.Ip
+	}
+	return nil
+}
+
+func (m *AddressPB) GetDomain() string {
+	if x, ok := m.GetAddress().(*AddressPB_Domain); ok {
+		return x.Domain
+	}
+	return ""
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*AddressPB) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _AddressPB_OneofMarshaler, _AddressPB_OneofUnmarshaler, _AddressPB_OneofSizer, []interface{}{
+		(*AddressPB_Ip)(nil),
+		(*AddressPB_Domain)(nil),
+	}
+}
+
+func _AddressPB_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*AddressPB)
+	// address
+	switch x := m.Address.(type) {
+	case *AddressPB_Ip:
+		b.EncodeVarint(1<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.Ip)
+	case *AddressPB_Domain:
+		b.EncodeVarint(2<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.Domain)
+	case nil:
+	default:
+		return fmt.Errorf("AddressPB.Address has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _AddressPB_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*AddressPB)
+	switch tag {
+	case 1: // address.ip
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.Address = &AddressPB_Ip{x}
+		return true, err
+	case 2: // address.domain
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.Address = &AddressPB_Domain{x}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _AddressPB_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*AddressPB)
+	// address
+	switch x := m.Address.(type) {
+	case *AddressPB_Ip:
+		n += proto.SizeVarint(1<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.Ip)))
+		n += len(x.Ip)
+	case *AddressPB_Domain:
+		n += proto.SizeVarint(2<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.Domain)))
+		n += len(x.Domain)
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+func init() {
+	proto.RegisterType((*AddressPB)(nil), "com.v2ray.core.common.net.AddressPB")
+}
+
+func init() { proto.RegisterFile("address.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 132 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x4d, 0x4c, 0x49, 0x29,
+	0x4a, 0x2d, 0x2e, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x92, 0x4c, 0xce, 0xcf, 0xd5, 0x2b,
+	0x33, 0x2a, 0x4a, 0xac, 0xd4, 0x4b, 0xce, 0x2f, 0x4a, 0xd5, 0x4b, 0xce, 0xcf, 0xcd, 0xcd, 0xcf,
+	0xd3, 0xcb, 0x4b, 0x2d, 0x51, 0x72, 0xe2, 0xe2, 0x74, 0x84, 0xa8, 0x0d, 0x70, 0x12, 0x12, 0xe0,
+	0x62, 0xca, 0x2c, 0x90, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0xf1, 0x60, 0x08, 0x62, 0xca, 0x2c, 0x10,
+	0x92, 0xe0, 0x62, 0x4b, 0xc9, 0xcf, 0x4d, 0xcc, 0xcc, 0x93, 0x60, 0x52, 0x60, 0xd4, 0xe0, 0xf4,
+	0x60, 0x08, 0x82, 0xf2, 0x9d, 0x38, 0xb9, 0xd8, 0xa1, 0x96, 0x38, 0xb1, 0x46, 0x31, 0xe7, 0xa5,
+	0x96, 0x24, 0xb1, 0x81, 0x2d, 0x33, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0xc9, 0xe5, 0x7b, 0x99,
+	0x7d, 0x00, 0x00, 0x00,
+}

common/net/address.proto

@@ -0,0 +1,11 @@
+syntax = "proto3";
+
+package com.v2ray.core.common.net;
+option go_package = "net";
+
+message AddressPB {
+  oneof address {
+    bytes ip = 1;
+    string domain = 2;
+  }
+}

common/net/address_json.go

@@ -6,15 +6,22 @@ import (
 	"encoding/json"
 )
 
-type AddressJson struct {
-	Address Address
-}
-
-func (this *AddressJson) UnmarshalJSON(data []byte) error {
+func (this *AddressPB) UnmarshalJSON(data []byte) error {
 	var rawStr string
 	if err := json.Unmarshal(data, &rawStr); err != nil {
 		return err
 	}
-	this.Address = ParseAddress(rawStr)
+	addr := ParseAddress(rawStr)
+	switch addr.Family() {
+	case AddressFamilyIPv4, AddressFamilyIPv6:
+		this.Address = &AddressPB_Ip{
+			Ip: []byte(addr.IP()),
+		}
+	case AddressFamilyDomain:
+		this.Address = &AddressPB_Domain{
+			Domain: addr.Domain(),
+		}
+	}
+
 	return nil
 }

common/net/address_json_test.go

@@ -4,7 +4,6 @@ package net_test
 
 import (
 	"encoding/json"
-	"net"
 	"testing"
 
 	. "v2ray.com/core/common/net"
@@ -15,31 +14,27 @@ func TestIPParsing(t *testing.T) {
 	assert := assert.On(t)
 
 	rawJson := "\"8.8.8.8\""
-	var address AddressJson
+	var address AddressPB
 	err := json.Unmarshal([]byte(rawJson), &address)
 	assert.Error(err).IsNil()
-	assert.Bool(address.Address.Family().Either(AddressFamilyIPv4)).IsTrue()
-	assert.Bool(address.Address.Family().Either(AddressFamilyDomain)).IsFalse()
-	assert.Bool(address.Address.IP().Equal(net.ParseIP("8.8.8.8"))).IsTrue()
+	assert.Bytes(address.GetIp()).Equals([]byte{8, 8, 8, 8})
 }
 
 func TestDomainParsing(t *testing.T) {
 	assert := assert.On(t)
 
 	rawJson := "\"v2ray.com\""
-	var address AddressJson
+	var address AddressPB
 	err := json.Unmarshal([]byte(rawJson), &address)
 	assert.Error(err).IsNil()
-	assert.Bool(address.Address.Family().Either(AddressFamilyIPv4)).IsFalse()
-	assert.Bool(address.Address.Family().Either(AddressFamilyDomain)).IsTrue()
-	assert.String(address.Address.Domain()).Equals("v2ray.com")
+	assert.String(address.GetDomain()).Equals("v2ray.com")
 }
 
 func TestInvalidAddressJson(t *testing.T) {
 	assert := assert.On(t)
 
 	rawJson := "1234"
-	var address AddressJson
+	var address AddressPB
 	err := json.Unmarshal([]byte(rawJson), &address)
 	assert.Error(err).IsNotNil()
 }

common/net/net.go

@@ -1,2 +1,4 @@
+//go:generate protoc --go_out=. address.proto port.proto
+
 // Package net contains common network utilities.
 package net

common/net/port.go

@@ -23,8 +23,8 @@ func PortFromBytes(port []byte) Port {
 
 // PortFromInt converts an integer to a Port.
 // @error when the integer is not positive or larger then 65535
-func PortFromInt(v int) (Port, error) {
-	if v <= 0 || v > 65535 {
+func PortFromInt(v uint32) (Port, error) {
+	if v > 65535 {
 		return Port(0), ErrInvalidPortRange
 	}
 	return Port(v), nil
@@ -33,11 +33,11 @@ func PortFromInt(v int) (Port, error) {
 // PortFromString converts a string to a Port.
 // @error when the string is not an integer or the integral value is a not a valid Port.
 func PortFromString(s string) (Port, error) {
-	v, err := strconv.Atoi(s)
+	v, err := strconv.ParseUint(s, 10, 32)
 	if err != nil {
 		return Port(0), ErrInvalidPortRange
 	}
-	return PortFromInt(v)
+	return PortFromInt(uint32(v))
 }
 
 // Value return the correspoding uint16 value of this Port.
@@ -55,13 +55,15 @@ func (this Port) String() string {
 	return serial.Uint16ToString(this.Value())
 }
 
-// PortRange represents a range of ports.
-type PortRange struct {
-	From Port
-	To   Port
+func (this PortRange) FromPort() Port {
+	return Port(this.From)
+}
+
+func (this PortRange) ToPort() Port {
+	return Port(this.To)
 }
 
 // Contains returns true if the given port is within the range of this PortRange.
 func (this PortRange) Contains(port Port) bool {
-	return this.From <= port && port <= this.To
+	return this.FromPort() <= port && port <= this.ToPort()
 }

common/net/port.pb.go

@@ -0,0 +1,43 @@
+// Code generated by protoc-gen-go.
+// source: port.proto
+// DO NOT EDIT!
+
+package net
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// PortRange represents a range of ports.
+type PortRange struct {
+	From uint32 `protobuf:"varint,1,opt,name=From,json=from" json:"From,omitempty"`
+	To   uint32 `protobuf:"varint,2,opt,name=To,json=to" json:"To,omitempty"`
+}
+
+func (m *PortRange) Reset()                    { *m = PortRange{} }
+func (m *PortRange) String() string            { return proto.CompactTextString(m) }
+func (*PortRange) ProtoMessage()               {}
+func (*PortRange) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
+
+func init() {
+	proto.RegisterType((*PortRange)(nil), "com.v2ray.core.common.net.PortRange")
+}
+
+func init() { proto.RegisterFile("port.proto", fileDescriptor1) }
+
+var fileDescriptor1 = []byte{
+	// 121 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x2a, 0xc8, 0x2f, 0x2a,
+	0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x92, 0x4c, 0xce, 0xcf, 0xd5, 0x2b, 0x33, 0x2a, 0x4a,
+	0xac, 0xd4, 0x4b, 0xce, 0x2f, 0x4a, 0xd5, 0x4b, 0xce, 0xcf, 0xcd, 0xcd, 0xcf, 0xd3, 0xcb, 0x4b,
+	0x2d, 0x51, 0xd2, 0xe7, 0xe2, 0x0c, 0xc8, 0x2f, 0x2a, 0x09, 0x4a, 0xcc, 0x4b, 0x4f, 0x15, 0x12,
+	0xe2, 0x62, 0x71, 0x2b, 0xca, 0xcf, 0x95, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0d, 0x62, 0x49, 0x2b,
+	0xca, 0xcf, 0x15, 0xe2, 0xe3, 0x62, 0x0a, 0xc9, 0x97, 0x60, 0x02, 0x8b, 0x30, 0x95, 0xe4, 0x3b,
+	0xb1, 0x46, 0x31, 0xe7, 0xa5, 0x96, 0x24, 0xb1, 0x81, 0x4d, 0x36, 0x06, 0x04, 0x00, 0x00, 0xff,
+	0xff, 0xd4, 0x6d, 0x95, 0xa8, 0x67, 0x00, 0x00, 0x00,
+}

common/net/port.proto

@@ -0,0 +1,10 @@
+syntax = "proto3";
+
+package com.v2ray.core.common.net;
+option go_package = "net";
+
+// PortRange represents a range of ports.
+message PortRange {
+  uint32 From = 1;
+  uint32 To = 2;
+}

common/net/port_json.go

@@ -10,7 +10,7 @@ import (
 )
 
 func parseIntPort(data []byte) (Port, error) {
-	var intPort int
+	var intPort uint32
 	err := json.Unmarshal(data, &intPort)
 	if err != nil {
 		return Port(0), err
@@ -48,15 +48,15 @@ func parseStringPort(data []byte) (Port, Port, error) {
 func (this *PortRange) UnmarshalJSON(data []byte) error {
 	port, err := parseIntPort(data)
 	if err == nil {
-		this.From = port
-		this.To = port
+		this.From = uint32(port)
+		this.To = uint32(port)
 		return nil
 	}
 
 	from, to, err := parseStringPort(data)
 	if err == nil {
-		this.From = from
-		this.To = to
+		this.From = uint32(from)
+		this.To = uint32(to)
 		if this.From > this.To {
 			log.Error("Invalid port range ", this.From, " -> ", this.To)
 			return ErrInvalidPortRange

common/net/port_json_test.go

@@ -17,8 +17,8 @@ func TestIntPort(t *testing.T) {
 	err := json.Unmarshal([]byte("1234"), &portRange)
 	assert.Error(err).IsNil()
 
-	assert.Uint16(portRange.From.Value()).Equals(uint16(1234))
-	assert.Uint16(portRange.To.Value()).Equals(uint16(1234))
+	assert.Uint32(portRange.From).Equals(1234)
+	assert.Uint32(portRange.To).Equals(1234)
 }
 
 func TestOverRangeIntPort(t *testing.T) {
@@ -39,8 +39,8 @@ func TestSingleStringPort(t *testing.T) {
 	err := json.Unmarshal([]byte("\"1234\""), &portRange)
 	assert.Error(err).IsNil()
 
-	assert.Uint16(portRange.From.Value()).Equals(uint16(1234))
-	assert.Uint16(portRange.To.Value()).Equals(uint16(1234))
+	assert.Uint32(portRange.From).Equals(1234)
+	assert.Uint32(portRange.To).Equals(1234)
 }
 
 func TestStringPairPort(t *testing.T) {
@@ -50,8 +50,8 @@ func TestStringPairPort(t *testing.T) {
 	err := json.Unmarshal([]byte("\"1234-5678\""), &portRange)
 	assert.Error(err).IsNil()
 
-	assert.Uint16(portRange.From.Value()).Equals(uint16(1234))
-	assert.Uint16(portRange.To.Value()).Equals(uint16(5678))
+	assert.Uint32(portRange.From).Equals(1234)
+	assert.Uint32(portRange.To).Equals(5678)
 }
 
 func TestOverRangeStringPort(t *testing.T) {

common/net/port_test.go

@@ -11,8 +11,8 @@ func TestPortRangeContains(t *testing.T) {
 	assert := assert.On(t)
 
 	portRange := &PortRange{
-		From: Port(53),
-		To:   Port(53),
+		From: 53,
+		To:   53,
 	}
 	assert.Bool(portRange.Contains(Port(53))).IsTrue()
 }