From 34a0cb0b70d557abbd5f95651081db44a2f1dcbd Mon Sep 17 00:00:00 2001 From: v2ray Date: Wed, 16 Dec 2015 23:53:38 +0100 Subject: [PATCH] move port out of address --- app/router/router_test.go | 2 +- app/router/rules/json/chinaip_test.go | 2 +- app/router/rules/json/chinasites_test.go | 2 +- app/router/rules/json/fieldrule.go | 2 +- app/router/rules/json/fieldrule_test.go | 16 +++--- app/router/rules/router_test.go | 2 +- common/net/address.go | 40 ++++---------- common/net/address_test.go | 23 +++----- common/net/destination.go | 64 ++++++++++++++-------- common/net/destination_test.go | 4 +- proxy/dokodemo/config.go | 1 + proxy/dokodemo/dokodemo.go | 6 +- proxy/dokodemo/dokodemo_test.go | 4 +- proxy/dokodemo/json/json.go | 10 +++- proxy/freedom/freedom.go | 2 +- proxy/freedom/freedom_test.go | 3 +- proxy/http/http.go | 16 +++--- proxy/socks/protocol/socks.go | 10 ++-- proxy/socks/protocol/udp.go | 19 ++++--- proxy/socks/protocol/udp_test.go | 5 +- proxy/socks/socks.go | 14 ++--- proxy/socks/socks_test.go | 4 +- proxy/socks/udp.go | 11 ++-- proxy/vmess/outbound/json/outbound.go | 12 ++-- proxy/vmess/outbound/json/outbound_test.go | 2 +- proxy/vmess/outbound/outbound.go | 22 ++++++-- proxy/vmess/outbound/receiver.go | 8 +-- proxy/vmess/protocol/vmess.go | 15 ++--- proxy/vmess/protocol/vmess_test.go | 6 +- proxy/vmess/vmess_test.go | 4 +- testing/scenarios/socks5_helper.go | 17 +++--- testing/scenarios/socks_end_test.go | 10 ++-- testing/servers/tcp/tcp.go | 4 +- testing/servers/udp/udp.go | 4 +- 34 files changed, 194 insertions(+), 172 deletions(-) diff --git a/app/router/router_test.go b/app/router/router_test.go index 12a0e8967..8723d949f 100644 --- a/app/router/router_test.go +++ b/app/router/router_test.go @@ -24,7 +24,7 @@ func TestRouter(t *testing.T) { router, err := CreateRouter(pointConfig.RouterConfig().Strategy(), pointConfig.RouterConfig().Settings()) assert.Error(err).IsNil() - dest := v2net.NewTCPDestination(v2net.IPAddress(net.ParseIP("120.135.126.1"), 80)) + dest := v2net.TCPDestination(v2net.IPAddress(net.ParseIP("120.135.126.1")), 80) tag, err := router.TakeDetour(dest) assert.Error(err).IsNil() assert.StringLiteral(tag).Equals("direct") diff --git a/app/router/rules/json/chinaip_test.go b/app/router/rules/json/chinaip_test.go index d90e34216..19ac0efe6 100644 --- a/app/router/rules/json/chinaip_test.go +++ b/app/router/rules/json/chinaip_test.go @@ -10,7 +10,7 @@ import ( ) func makeDestination(ip string) v2net.Destination { - return v2net.NewTCPDestination(v2net.IPAddress(net.ParseIP(ip), 80)) + return v2net.TCPDestination(v2net.IPAddress(net.ParseIP(ip)), 80) } func TestChinaIP(t *testing.T) { diff --git a/app/router/rules/json/chinasites_test.go b/app/router/rules/json/chinasites_test.go index ae83b4b89..e4fdeffb4 100644 --- a/app/router/rules/json/chinasites_test.go +++ b/app/router/rules/json/chinasites_test.go @@ -9,7 +9,7 @@ import ( ) func makeDomainDestination(domain string) v2net.Destination { - return v2net.NewTCPDestination(v2net.DomainAddress(domain, 80)) + return v2net.TCPDestination(v2net.DomainAddress(domain), 80) } func TestChinaSites(t *testing.T) { diff --git a/app/router/rules/json/fieldrule.go b/app/router/rules/json/fieldrule.go index 481aba4ad..d74b5aaac 100644 --- a/app/router/rules/json/fieldrule.go +++ b/app/router/rules/json/fieldrule.go @@ -121,7 +121,7 @@ func (this *FieldRule) Apply(dest v2net.Destination) bool { } if this.Port != nil { - port := address.Port() + port := dest.Port() if port.Value() < this.Port.From().Value() || port.Value() > this.Port.To().Value() { return false } diff --git a/app/router/rules/json/fieldrule_test.go b/app/router/rules/json/fieldrule_test.go index bd20034e2..02876f162 100644 --- a/app/router/rules/json/fieldrule_test.go +++ b/app/router/rules/json/fieldrule_test.go @@ -39,7 +39,7 @@ func TestDomainMatching(t *testing.T) { "tag": "test" }` rule := parseRule([]byte(rawJson)) - dest := v2net.NewTCPDestination(v2net.DomainAddress("www.v2ray.com", 80)) + dest := v2net.TCPDestination(v2net.DomainAddress("www.v2ray.com"), 80) assert.Bool(rule.Apply(dest)).IsTrue() } @@ -52,7 +52,7 @@ func TestPortMatching(t *testing.T) { ToValue: 100, }, } - dest := v2net.NewTCPDestination(v2net.DomainAddress("www.v2ray.com", 80)) + dest := v2net.TCPDestination(v2net.DomainAddress("www.v2ray.com"), 80) assert.Bool(rule.Apply(dest)).IsTrue() } @@ -65,7 +65,7 @@ func TestIPMatching(t *testing.T) { "tag": "test" }` rule := parseRule([]byte(rawJson)) - dest := v2net.NewTCPDestination(v2net.IPAddress([]byte{10, 0, 0, 1}, 80)) + dest := v2net.TCPDestination(v2net.IPAddress([]byte{10, 0, 0, 1}), 80) assert.Bool(rule.Apply(dest)).IsTrue() } @@ -78,7 +78,7 @@ func TestIPListMatching(t *testing.T) { "tag": "test" }` rule := parseRule([]byte(rawJson)) - dest := v2net.NewTCPDestination(v2net.IPAddress([]byte{192, 168, 1, 1}, 80)) + dest := v2net.TCPDestination(v2net.IPAddress([]byte{192, 168, 1, 1}), 80) assert.Bool(rule.Apply(dest)).IsTrue() } @@ -91,7 +91,7 @@ func TestPortNotMatching(t *testing.T) { "tag": "test" }` rule := parseRule([]byte(rawJson)) - dest := v2net.NewTCPDestination(v2net.IPAddress([]byte{10, 0, 0, 1}, 79)) + dest := v2net.TCPDestination(v2net.IPAddress([]byte{10, 0, 0, 1}), 79) assert.Bool(rule.Apply(dest)).IsFalse() } @@ -104,7 +104,7 @@ func TestDomainNotMatching(t *testing.T) { "tag": "test" }` rule := parseRule([]byte(rawJson)) - dest := v2net.NewTCPDestination(v2net.IPAddress([]byte{10, 0, 0, 1}, 80)) + dest := v2net.TCPDestination(v2net.IPAddress([]byte{10, 0, 0, 1}), 80) assert.Bool(rule.Apply(dest)).IsFalse() } @@ -117,9 +117,9 @@ func TestDomainNotMatchingDomain(t *testing.T) { "tag": "test" }` rule := parseRule([]byte(rawJson)) - dest := v2net.NewTCPDestination(v2net.DomainAddress("baidu.com", 80)) + dest := v2net.TCPDestination(v2net.DomainAddress("baidu.com"), 80) assert.Bool(rule.Apply(dest)).IsFalse() - dest = v2net.NewTCPDestination(v2net.DomainAddress("www.google.com", 80)) + dest = v2net.TCPDestination(v2net.DomainAddress("www.google.com"), 80) assert.Bool(rule.Apply(dest)).IsTrue() } diff --git a/app/router/rules/router_test.go b/app/router/rules/router_test.go index ad864af16..93473e589 100644 --- a/app/router/rules/router_test.go +++ b/app/router/rules/router_test.go @@ -21,7 +21,7 @@ func TestSimpleRouter(t *testing.T) { }, }) - tag, err := router.TakeDetour(v2net.NewTCPDestination(v2net.DomainAddress("v2ray.com", 80))) + tag, err := router.TakeDetour(v2net.TCPDestination(v2net.DomainAddress("v2ray.com"), 80)) assert.Error(err).IsNil() assert.StringLiteral(tag).Equals("test") } diff --git a/common/net/address.go b/common/net/address.go index 891fd5c9c..0a0244c7e 100644 --- a/common/net/address.go +++ b/common/net/address.go @@ -11,7 +11,6 @@ import ( type Address interface { IP() net.IP // IP of this Address Domain() string // Domain of this Address - Port() Port // Port of this Address IsIPv4() bool // True if this Address is an IPv4 address IsIPv6() bool // True if this Address is an IPv6 address @@ -30,19 +29,17 @@ func allZeros(data []byte) bool { } // IPAddress creates an Address with given IP and port. -func IPAddress(ip []byte, port Port) Address { +func IPAddress(ip []byte) Address { switch len(ip) { case net.IPv4len: return &IPv4Address{ - port: port, - ip: [4]byte{ip[0], ip[1], ip[2], ip[3]}, + ip: [4]byte{ip[0], ip[1], ip[2], ip[3]}, } case net.IPv6len: if allZeros(ip[0:10]) && ip[10] == 0xff && ip[11] == 0xff { - return IPAddress(ip[12:16], port) + return IPAddress(ip[12:16]) } return &IPv6Address{ - port: Port(port), ip: [16]byte{ ip[0], ip[1], ip[2], ip[3], ip[4], ip[5], ip[6], ip[7], @@ -57,26 +54,23 @@ func IPAddress(ip []byte, port Port) Address { } // DomainAddress creates an Address with given domain and port. -func DomainAddress(domain string, port Port) Address { +func DomainAddress(domain string) Address { return &DomainAddressImpl{ domain: domain, - port: port, } } +type address struct { +} + type IPv4Address struct { - port Port - ip [4]byte + ip [4]byte } func (addr *IPv4Address) IP() net.IP { return net.IP(addr.ip[:]) } -func (this *IPv4Address) Port() Port { - return this.port -} - func (addr *IPv4Address) Domain() string { panic("Calling Domain() on an IPv4Address.") } @@ -94,22 +88,17 @@ func (addr *IPv4Address) IsDomain() bool { } func (this *IPv4Address) String() string { - return this.IP().String() + ":" + this.port.String() + return this.IP().String() } type IPv6Address struct { - port Port - ip [16]byte + ip [16]byte } func (addr *IPv6Address) IP() net.IP { return net.IP(addr.ip[:]) } -func (this *IPv6Address) Port() Port { - return this.port -} - func (addr *IPv6Address) Domain() string { panic("Calling Domain() on an IPv6Address.") } @@ -127,11 +116,10 @@ func (addr *IPv6Address) IsDomain() bool { } func (this *IPv6Address) String() string { - return "[" + this.IP().String() + "]:" + this.port.String() + return "[" + this.IP().String() + "]" } type DomainAddressImpl struct { - port Port domain string } @@ -139,10 +127,6 @@ func (addr *DomainAddressImpl) IP() net.IP { panic("Calling IP() on a DomainAddress.") } -func (this *DomainAddressImpl) Port() Port { - return this.port -} - func (addr *DomainAddressImpl) Domain() string { return addr.domain } @@ -160,5 +144,5 @@ func (addr *DomainAddressImpl) IsDomain() bool { } func (this *DomainAddressImpl) String() string { - return this.domain + ":" + this.port.String() + return this.domain } diff --git a/common/net/address_test.go b/common/net/address_test.go index d40e0c14b..f8ac60630 100644 --- a/common/net/address_test.go +++ b/common/net/address_test.go @@ -14,15 +14,13 @@ func TestIPv4Address(t *testing.T) { v2testing.Current(t) ip := []byte{byte(1), byte(2), byte(3), byte(4)} - port := v2net.Port(80) - addr := v2net.IPAddress(ip, port) + addr := v2net.IPAddress(ip) v2netassert.Address(addr).IsIPv4() v2netassert.Address(addr).IsNotIPv6() v2netassert.Address(addr).IsNotDomain() assert.Bytes(addr.IP()).Equals(ip) - v2netassert.Port(addr.Port()).Equals(port) - assert.String(addr).Equals("1.2.3.4:80") + assert.String(addr).Equals("1.2.3.4") } func TestIPv6Address(t *testing.T) { @@ -34,38 +32,33 @@ func TestIPv6Address(t *testing.T) { byte(1), byte(2), byte(3), byte(4), byte(1), byte(2), byte(3), byte(4), } - port := v2net.Port(443) - addr := v2net.IPAddress(ip, port) + addr := v2net.IPAddress(ip) v2netassert.Address(addr).IsIPv6() v2netassert.Address(addr).IsNotIPv4() v2netassert.Address(addr).IsNotDomain() assert.Bytes(addr.IP()).Equals(ip) - v2netassert.Port(addr.Port()).Equals(port) - assert.String(addr).Equals("[102:304:102:304:102:304:102:304]:443") + assert.String(addr).Equals("[102:304:102:304:102:304:102:304]") } func TestDomainAddress(t *testing.T) { v2testing.Current(t) domain := "v2ray.com" - port := v2net.Port(443) - addr := v2net.DomainAddress(domain, port) + addr := v2net.DomainAddress(domain) v2netassert.Address(addr).IsDomain() v2netassert.Address(addr).IsNotIPv6() v2netassert.Address(addr).IsNotIPv4() assert.StringLiteral(addr.Domain()).Equals(domain) - v2netassert.Port(addr.Port()).Equals(port) - assert.String(addr).Equals("v2ray.com:443") + assert.String(addr).Equals("v2ray.com") } func TestNetIPv4Address(t *testing.T) { v2testing.Current(t) ip := net.IPv4(1, 2, 3, 4) - port := v2net.Port(80) - addr := v2net.IPAddress(ip, port) + addr := v2net.IPAddress(ip) v2netassert.Address(addr).IsIPv4() - assert.String(addr).Equals("1.2.3.4:80") + assert.String(addr).Equals("1.2.3.4") } diff --git a/common/net/destination.go b/common/net/destination.go index f495f05f3..dd72a14d9 100644 --- a/common/net/destination.go +++ b/common/net/destination.go @@ -4,66 +4,86 @@ package net type Destination interface { Network() string // Protocol of communication (tcp / udp) Address() Address // Address of destination - String() string // String representation of the destination + Port() Port + String() string // String representation of the destination + NetAddr() string IsTCP() bool // True if destination is reachable via TCP IsUDP() bool // True if destination is reachable via UDP } -// NewTCPDestination creates a TCP destination with given address -func NewTCPDestination(address Address) Destination { - return TCPDestination{address: address} +// TCPDestination creates a TCP destination with given address +func TCPDestination(address Address, port Port) Destination { + return &tcpDestination{address: address, port: port} } -// NewUDPDestination creates a UDP destination with given address -func NewUDPDestination(address Address) Destination { - return UDPDestination{address: address} +// UDPDestination creates a UDP destination with given address +func UDPDestination(address Address, port Port) Destination { + return &udpDestination{address: address, port: port} } -type TCPDestination struct { +type tcpDestination struct { address Address + port Port } -func (dest TCPDestination) Network() string { +func (dest *tcpDestination) Network() string { return "tcp" } -func (dest TCPDestination) Address() Address { +func (dest *tcpDestination) Address() Address { return dest.address } -func (dest TCPDestination) String() string { - return "tcp:" + dest.address.String() +func (dest *tcpDestination) NetAddr() string { + return dest.address.String() + ":" + dest.port.String() } -func (dest TCPDestination) IsTCP() bool { +func (dest *tcpDestination) String() string { + return "tcp:" + dest.NetAddr() +} + +func (dest *tcpDestination) IsTCP() bool { return true } -func (dest TCPDestination) IsUDP() bool { +func (dest *tcpDestination) IsUDP() bool { return false } -type UDPDestination struct { - address Address +func (dest *tcpDestination) Port() Port { + return dest.port } -func (dest UDPDestination) Network() string { +type udpDestination struct { + address Address + port Port +} + +func (dest *udpDestination) Network() string { return "udp" } -func (dest UDPDestination) Address() Address { +func (dest *udpDestination) Address() Address { return dest.address } -func (dest UDPDestination) String() string { - return "udp:" + dest.address.String() +func (dest *udpDestination) NetAddr() string { + return dest.address.String() + ":" + dest.port.String() } -func (dest UDPDestination) IsTCP() bool { +func (dest *udpDestination) String() string { + return "udp:" + dest.NetAddr() +} + +func (dest *udpDestination) IsTCP() bool { return false } -func (dest UDPDestination) IsUDP() bool { +func (dest *udpDestination) IsUDP() bool { return true } + +func (dest *udpDestination) Port() Port { + return dest.port +} diff --git a/common/net/destination_test.go b/common/net/destination_test.go index f16913923..e17b6dbb8 100644 --- a/common/net/destination_test.go +++ b/common/net/destination_test.go @@ -12,7 +12,7 @@ import ( func TestTCPDestination(t *testing.T) { v2testing.Current(t) - dest := v2net.NewTCPDestination(v2net.IPAddress([]byte{1, 2, 3, 4}, 80)) + dest := v2net.TCPDestination(v2net.IPAddress([]byte{1, 2, 3, 4}), 80) v2netassert.Destination(dest).IsTCP() v2netassert.Destination(dest).IsNotUDP() assert.String(dest).Equals("tcp:1.2.3.4:80") @@ -21,7 +21,7 @@ func TestTCPDestination(t *testing.T) { func TestUDPDestination(t *testing.T) { v2testing.Current(t) - dest := v2net.NewUDPDestination(v2net.IPAddress([]byte{0x20, 0x01, 0x48, 0x60, 0x48, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x88}, 53)) + dest := v2net.UDPDestination(v2net.IPAddress([]byte{0x20, 0x01, 0x48, 0x60, 0x48, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x88}), 53) v2netassert.Destination(dest).IsNotTCP() v2netassert.Destination(dest).IsUDP() assert.String(dest).Equals("udp:[2001:4860:4860::8888]:53") diff --git a/proxy/dokodemo/config.go b/proxy/dokodemo/config.go index fb55ae50f..f9ea64c4b 100644 --- a/proxy/dokodemo/config.go +++ b/proxy/dokodemo/config.go @@ -6,6 +6,7 @@ import ( type Config interface { Address() v2net.Address + Port() v2net.Port Network() v2net.NetworkList Timeout() int } diff --git a/proxy/dokodemo/dokodemo.go b/proxy/dokodemo/dokodemo.go index f1562997c..bfbb3441c 100644 --- a/proxy/dokodemo/dokodemo.go +++ b/proxy/dokodemo/dokodemo.go @@ -16,6 +16,7 @@ type DokodemoDoor struct { config Config accepting bool address v2net.Address + port v2net.Port space app.Space } @@ -24,6 +25,7 @@ func NewDokodemoDoor(space app.Space, config Config) *DokodemoDoor { config: config, space: space, address: config.Address(), + port: config.Port(), } } @@ -71,7 +73,7 @@ func (this *DokodemoDoor) handleUDPPackets(udpConn *net.UDPConn) { return } - packet := v2net.NewPacket(v2net.NewUDPDestination(this.address), buffer, false) + packet := v2net.NewPacket(v2net.UDPDestination(this.address, this.port), buffer, false) ray := this.space.PacketDispatcher().DispatchToOutbound(packet) close(ray.InboundInput()) @@ -112,7 +114,7 @@ func (this *DokodemoDoor) AcceptTCPConnections(tcpListener *net.TCPListener) { func (this *DokodemoDoor) HandleTCPConnection(conn *net.TCPConn) { defer conn.Close() - packet := v2net.NewPacket(v2net.NewTCPDestination(this.address), nil, true) + packet := v2net.NewPacket(v2net.TCPDestination(this.address, this.port), nil, true) ray := this.space.PacketDispatcher().DispatchToOutbound(packet) var inputFinish, outputFinish sync.Mutex diff --git a/proxy/dokodemo/dokodemo_test.go b/proxy/dokodemo/dokodemo_test.go index 702e566ce..5f8b0922b 100644 --- a/proxy/dokodemo/dokodemo_test.go +++ b/proxy/dokodemo/dokodemo_test.go @@ -43,7 +43,7 @@ func TestDokodemoTCP(t *testing.T) { ProtocolValue: "dokodemo-door", SettingsValue: &json.DokodemoConfig{ Host: v2netjson.NewIPHost(net.ParseIP("127.0.0.1")), - Port: port, + PortValue: port, NetworkList: &networkList, TimeoutValue: 0, }, @@ -105,7 +105,7 @@ func TestDokodemoUDP(t *testing.T) { ProtocolValue: "dokodemo-door", SettingsValue: &json.DokodemoConfig{ Host: v2netjson.NewIPHost(net.ParseIP("127.0.0.1")), - Port: port, + PortValue: port, NetworkList: &networkList, TimeoutValue: 0, }, diff --git a/proxy/dokodemo/json/json.go b/proxy/dokodemo/json/json.go index 560aad72e..839a6f4f6 100644 --- a/proxy/dokodemo/json/json.go +++ b/proxy/dokodemo/json/json.go @@ -8,19 +8,23 @@ import ( type DokodemoConfig struct { Host *v2netjson.Host `json:"address"` - Port v2net.Port `json:"port"` + PortValue v2net.Port `json:"port"` NetworkList *v2netjson.NetworkList `json:"network"` TimeoutValue int `json:"timeout"` } func (this *DokodemoConfig) Address() v2net.Address { if this.Host.IsIP() { - return v2net.IPAddress(this.Host.IP(), this.Port) + return v2net.IPAddress(this.Host.IP()) } else { - return v2net.DomainAddress(this.Host.Domain(), this.Port) + return v2net.DomainAddress(this.Host.Domain()) } } +func (this *DokodemoConfig) Port() v2net.Port { + return this.PortValue +} + func (this *DokodemoConfig) Network() v2net.NetworkList { return this.NetworkList } diff --git a/proxy/freedom/freedom.go b/proxy/freedom/freedom.go index c686db622..78860e25d 100644 --- a/proxy/freedom/freedom.go +++ b/proxy/freedom/freedom.go @@ -15,7 +15,7 @@ type FreedomConnection struct { } func (this *FreedomConnection) Dispatch(firstPacket v2net.Packet, ray ray.OutboundRay) error { - conn, err := net.Dial(firstPacket.Destination().Network(), firstPacket.Destination().Address().String()) + conn, err := net.Dial(firstPacket.Destination().Network(), firstPacket.Destination().NetAddr()) log.Info("Freedom: Opening connection to %s", firstPacket.Destination().String()) if err != nil { close(ray.OutboundOutput()) diff --git a/proxy/freedom/freedom_test.go b/proxy/freedom/freedom_test.go index 0c46db982..862c4216a 100644 --- a/proxy/freedom/freedom_test.go +++ b/proxy/freedom/freedom_test.go @@ -70,8 +70,7 @@ func TestUDPSend(t *testing.T) { data2SendBuffer := alloc.NewBuffer().Clear() data2SendBuffer.Append([]byte(data2Send)) - dest := v2net.NewUDPDestination(udpServerAddr) - ich.Communicate(v2net.NewPacket(dest, data2SendBuffer, false)) + ich.Communicate(v2net.NewPacket(udpServerAddr, data2SendBuffer, false)) assert.Bytes(connOutput.Bytes()).Equals([]byte("Processed: Data to be sent to remote")) } diff --git a/proxy/http/http.go b/proxy/http/http.go index f30d7cce0..cc12c7236 100644 --- a/proxy/http/http.go +++ b/proxy/http/http.go @@ -53,7 +53,7 @@ func (this *HttpProxyServer) accept(listener *net.TCPListener) { } } -func parseHost(rawHost string, defaultPort v2net.Port) (v2net.Address, error) { +func parseHost(rawHost string, defaultPort v2net.Port) (v2net.Destination, error) { port := defaultPort host, rawPort, err := net.SplitHostPort(rawHost) if err != nil { @@ -71,9 +71,9 @@ func parseHost(rawHost string, defaultPort v2net.Port) (v2net.Address, error) { } if ip := net.ParseIP(host); ip != nil { - return v2net.IPAddress(ip, port), nil + return v2net.TCPDestination(v2net.IPAddress(ip), port), nil } - return v2net.DomainAddress(host, port), nil + return v2net.TCPDestination(v2net.DomainAddress(host), port), nil } func (this *HttpProxyServer) handleConnection(conn *net.TCPConn) { @@ -93,12 +93,12 @@ func (this *HttpProxyServer) handleConnection(conn *net.TCPConn) { if len(host) == 0 { host = request.URL.Host } - address, err := parseHost(host, defaultPort) + dest, err := parseHost(host, defaultPort) if err != nil { log.Warning("Malformed proxy host (%s): %v", host, err) } if strings.ToUpper(request.Method) == "CONNECT" { - this.handleConnect(request, address, reader, conn) + this.handleConnect(request, dest, reader, conn) } else if len(request.URL.Host) > 0 { request.Host = request.URL.Host request.Header.Set("Connection", "keep-alive") @@ -106,7 +106,7 @@ func (this *HttpProxyServer) handleConnection(conn *net.TCPConn) { buffer := alloc.NewBuffer().Clear() request.Write(buffer) log.Info("Request to remote: %s", string(buffer.Value)) - packet := v2net.NewPacket(v2net.NewTCPDestination(address), buffer, true) + packet := v2net.NewPacket(dest, buffer, true) ray := this.space.PacketDispatcher().DispatchToOutbound(packet) go func() { defer close(ray.InboundInput()) @@ -142,7 +142,7 @@ func (this *HttpProxyServer) handleConnection(conn *net.TCPConn) { } } -func (this *HttpProxyServer) handleConnect(request *http.Request, address v2net.Address, reader io.Reader, writer io.Writer) { +func (this *HttpProxyServer) handleConnect(request *http.Request, destination v2net.Destination, reader io.Reader, writer io.Writer) { response := &http.Response{ Status: "200 OK", StatusCode: 200, @@ -160,7 +160,7 @@ func (this *HttpProxyServer) handleConnect(request *http.Request, address v2net. writer.Write(buffer.Value) buffer.Release() - packet := v2net.NewPacket(v2net.NewTCPDestination(address), nil, true) + packet := v2net.NewPacket(destination, nil, true) ray := this.space.PacketDispatcher().DispatchToOutbound(packet) this.transport(reader, writer, ray) } diff --git a/proxy/socks/protocol/socks.go b/proxy/socks/protocol/socks.go index 29a06d23c..dd72143bd 100644 --- a/proxy/socks/protocol/socks.go +++ b/proxy/socks/protocol/socks.go @@ -261,23 +261,21 @@ func ReadRequest(reader io.Reader) (request *Socks5Request, err error) { } func (request *Socks5Request) Destination() v2net.Destination { - var address v2net.Address switch request.AddrType { case AddrTypeIPv4: - address = v2net.IPAddress(request.IPv4[:], request.Port) + return v2net.TCPDestination(v2net.IPAddress(request.IPv4[:]), request.Port) case AddrTypeIPv6: - address = v2net.IPAddress(request.IPv6[:], request.Port) + return v2net.TCPDestination(v2net.IPAddress(request.IPv6[:]), request.Port) case AddrTypeDomain: maybeIP := net.ParseIP(request.Domain) if maybeIP != nil { - address = v2net.IPAddress(maybeIP, request.Port) + return v2net.TCPDestination(v2net.IPAddress(maybeIP), request.Port) } else { - address = v2net.DomainAddress(request.Domain, request.Port) + return v2net.TCPDestination(v2net.DomainAddress(request.Domain), request.Port) } default: panic("Unknown address type") } - return v2net.NewTCPDestination(address) } const ( diff --git a/proxy/socks/protocol/udp.go b/proxy/socks/protocol/udp.go index 1730c9077..1bce02d7a 100644 --- a/proxy/socks/protocol/udp.go +++ b/proxy/socks/protocol/udp.go @@ -17,11 +17,12 @@ var ( type Socks5UDPRequest struct { Fragment byte Address v2net.Address + Port v2net.Port Data *alloc.Buffer } func (request *Socks5UDPRequest) Destination() v2net.Destination { - return v2net.NewUDPDestination(request.Address) + return v2net.UDPDestination(request.Address, request.Port) } func (request *Socks5UDPRequest) Write(buffer *alloc.Buffer) { @@ -34,7 +35,7 @@ func (request *Socks5UDPRequest) Write(buffer *alloc.Buffer) { case request.Address.IsDomain(): buffer.AppendBytes(AddrTypeDomain, byte(len(request.Address.Domain()))).Append([]byte(request.Address.Domain())) } - buffer.Append(request.Address.Port().Bytes()) + buffer.Append(request.Port.Bytes()) buffer.Append(request.Data.Value) } @@ -56,16 +57,16 @@ func ReadUDPRequest(packet []byte) (*Socks5UDPRequest, error) { return nil, transport.CorruptedPacket } ip := packet[4:8] - port := v2net.PortFromBytes(packet[8:10]) - request.Address = v2net.IPAddress(ip, port) + request.Port = v2net.PortFromBytes(packet[8:10]) + request.Address = v2net.IPAddress(ip) dataBegin = 10 case AddrTypeIPv6: if len(packet) < 22 { return nil, transport.CorruptedPacket } ip := packet[4:20] - port := v2net.PortFromBytes(packet[20:22]) - request.Address = v2net.IPAddress(ip, port) + request.Port = v2net.PortFromBytes(packet[20:22]) + request.Address = v2net.IPAddress(ip) dataBegin = 22 case AddrTypeDomain: domainLength := int(packet[4]) @@ -73,12 +74,12 @@ func ReadUDPRequest(packet []byte) (*Socks5UDPRequest, error) { return nil, transport.CorruptedPacket } domain := string(packet[5 : 5+domainLength]) - port := v2net.PortFromBytes(packet[5+domainLength : 5+domainLength+2]) + request.Port = v2net.PortFromBytes(packet[5+domainLength : 5+domainLength+2]) maybeIP := net.ParseIP(domain) if maybeIP != nil { - request.Address = v2net.IPAddress(maybeIP, port) + request.Address = v2net.IPAddress(maybeIP) } else { - request.Address = v2net.DomainAddress(domain, port) + request.Address = v2net.DomainAddress(domain) } dataBegin = 5 + domainLength + 2 default: diff --git a/proxy/socks/protocol/udp_test.go b/proxy/socks/protocol/udp_test.go index 0ad798172..58fdd5510 100644 --- a/proxy/socks/protocol/udp_test.go +++ b/proxy/socks/protocol/udp_test.go @@ -3,6 +3,8 @@ package protocol import ( "testing" + v2net "github.com/v2ray/v2ray-core/common/net" + netassert "github.com/v2ray/v2ray-core/common/net/testing/assert" v2testing "github.com/v2ray/v2ray-core/testing" "github.com/v2ray/v2ray-core/testing/assert" "github.com/v2ray/v2ray-core/transport" @@ -31,6 +33,7 @@ func TestDomainAddressRequest(t *testing.T) { assert.Error(err).IsNil() assert.Byte(request.Fragment).Equals(1) - assert.String(request.Address).Equals("v2ray.com:80") + assert.String(request.Address).Equals("v2ray.com") + netassert.Port(request.Port).Equals(v2net.Port(80)) assert.Bytes(request.Data.Value).Equals([]byte("Actual payload")) } diff --git a/proxy/socks/socks.go b/proxy/socks/socks.go index fcaec8754..f483f0ca6 100644 --- a/proxy/socks/socks.go +++ b/proxy/socks/socks.go @@ -191,12 +191,12 @@ func (this *SocksServer) handleUDP(reader *v2net.TimeOutReader, writer io.Writer response.Port = udpAddr.Port() switch { - case udpAddr.IsIPv4(): - response.SetIPv4(udpAddr.IP()) - case udpAddr.IsIPv6(): - response.SetIPv6(udpAddr.IP()) - case udpAddr.IsDomain(): - response.SetDomain(udpAddr.Domain()) + case udpAddr.Address().IsIPv4(): + response.SetIPv4(udpAddr.Address().IP()) + case udpAddr.Address().IsIPv6(): + response.SetIPv6(udpAddr.Address().IP()) + case udpAddr.Address().IsDomain(): + response.SetDomain(udpAddr.Address().Domain()) } responseBuffer := alloc.NewSmallBuffer().Clear() @@ -236,7 +236,7 @@ func (this *SocksServer) handleSocks4(reader io.Reader, writer io.Writer, auth p return UnsupportedSocksCommand } - dest := v2net.NewTCPDestination(v2net.IPAddress(auth.IP[:], auth.Port)) + dest := v2net.TCPDestination(v2net.IPAddress(auth.IP[:]), auth.Port) packet := v2net.NewPacket(dest, nil, true) this.transport(reader, writer, packet) return nil diff --git a/proxy/socks/socks_test.go b/proxy/socks/socks_test.go index 1c6be4635..7b31529a9 100644 --- a/proxy/socks/socks_test.go +++ b/proxy/socks/socks_test.go @@ -71,7 +71,7 @@ func TestSocksTcpConnect(t *testing.T) { assert.Bytes([]byte(data2Send)).Equals(connOutput.Bytes()) assert.Bytes(dataReturned).Equals(connInput) - assert.StringLiteral(targetServer).Equals(och.Destination.Address().String()) + assert.StringLiteral(targetServer).Equals(och.Destination.NetAddr()) } func TestSocksTcpConnectWithUserPass(t *testing.T) { @@ -129,7 +129,7 @@ func TestSocksTcpConnectWithUserPass(t *testing.T) { assert.Bytes([]byte(data2Send)).Equals(connOutput.Bytes()) assert.Bytes(dataReturned).Equals(connInput) - assert.StringLiteral(targetServer).Equals(och.Destination.Address().String()) + assert.StringLiteral(targetServer).Equals(och.Destination.NetAddr()) } func TestSocksTcpConnectWithWrongUserPass(t *testing.T) { diff --git a/proxy/socks/udp.go b/proxy/socks/udp.go index 7437f03f9..9a8c8a112 100644 --- a/proxy/socks/udp.go +++ b/proxy/socks/udp.go @@ -9,7 +9,7 @@ import ( "github.com/v2ray/v2ray-core/proxy/socks/protocol" ) -var udpAddress v2net.Address +var udpAddress v2net.Destination func (this *SocksServer) ListenUDP(port v2net.Port) error { addr := &net.UDPAddr{ @@ -22,13 +22,13 @@ func (this *SocksServer) ListenUDP(port v2net.Port) error { log.Error("Socks failed to listen UDP on port %d: %v", port, err) return err } - udpAddress = v2net.IPAddress(this.config.IP(), port) + udpAddress = v2net.UDPDestination(v2net.IPAddress(this.config.IP()), port) go this.AcceptPackets(conn) return nil } -func (this *SocksServer) getUDPAddr() v2net.Address { +func (this *SocksServer) getUDPAddr() v2net.Destination { return udpAddress } @@ -60,11 +60,11 @@ func (this *SocksServer) AcceptPackets(conn *net.UDPConn) error { udpPacket := v2net.NewPacket(request.Destination(), request.Data, false) log.Info("Send packet to %s with %d bytes", udpPacket.Destination().String(), request.Data.Len()) - go this.handlePacket(conn, udpPacket, addr, request.Address) + go this.handlePacket(conn, udpPacket, addr, request.Address, request.Port) } } -func (this *SocksServer) handlePacket(conn *net.UDPConn, packet v2net.Packet, clientAddr *net.UDPAddr, targetAddr v2net.Address) { +func (this *SocksServer) handlePacket(conn *net.UDPConn, packet v2net.Packet, clientAddr *net.UDPAddr, targetAddr v2net.Address, port v2net.Port) { ray := this.space.PacketDispatcher().DispatchToOutbound(packet) close(ray.InboundInput()) @@ -72,6 +72,7 @@ func (this *SocksServer) handlePacket(conn *net.UDPConn, packet v2net.Packet, cl response := &protocol.Socks5UDPRequest{ Fragment: 0, Address: targetAddr, + Port: port, Data: data, } log.Info("Writing back UDP response with %d bytes from %s to %s", data.Len(), targetAddr.String(), clientAddr.String()) diff --git a/proxy/vmess/outbound/json/outbound.go b/proxy/vmess/outbound/json/outbound.go index d08b8aa54..fa273468f 100644 --- a/proxy/vmess/outbound/json/outbound.go +++ b/proxy/vmess/outbound/json/outbound.go @@ -14,8 +14,8 @@ import ( ) type ConfigTarget struct { - Address v2net.Address - Users []*vmessjson.ConfigUser + Destination v2net.Destination + Users []*vmessjson.ConfigUser } func (t *ConfigTarget) UnmarshalJSON(data []byte) error { @@ -38,9 +38,9 @@ func (t *ConfigTarget) UnmarshalJSON(data []byte) error { return proxyconfig.BadConfiguration } if rawConfig.Address.IsIP() { - t.Address = v2net.IPAddress(rawConfig.Address.IP(), rawConfig.Port) + t.Destination = v2net.TCPDestination(v2net.IPAddress(rawConfig.Address.IP()), rawConfig.Port) } else { - t.Address = v2net.DomainAddress(rawConfig.Address.Domain(), rawConfig.Port) + t.Destination = v2net.TCPDestination(v2net.DomainAddress(rawConfig.Address.Domain()), rawConfig.Port) } return nil } @@ -74,8 +74,8 @@ func (o *Outbound) Receivers() []*outbound.Receiver { users = append(users, rawUser) } targets = append(targets, &outbound.Receiver{ - Address: rawTarget.Address, - Accounts: users, + Destination: rawTarget.Destination, + Accounts: users, }) } return targets diff --git a/proxy/vmess/outbound/json/outbound_test.go b/proxy/vmess/outbound/json/outbound_test.go index 69bfb33f8..d782d6ec1 100644 --- a/proxy/vmess/outbound/json/outbound_test.go +++ b/proxy/vmess/outbound/json/outbound_test.go @@ -27,7 +27,7 @@ func TestConfigTargetParsing(t *testing.T) { var target *jsonconfig.ConfigTarget err := json.Unmarshal([]byte(rawJson), &target) assert.Error(err).IsNil() - assert.String(target.Address).Equals("127.0.0.1:80") + assert.String(target.Destination).Equals("tcp:127.0.0.1:80") assert.Int(len(target.Users)).Equals(1) assert.String(target.Users[0].ID()).Equals("e641f5ad-9397-41e3-bf1a-e8740dfed019") } diff --git a/proxy/vmess/outbound/outbound.go b/proxy/vmess/outbound/outbound.go index 2760bd58e..22733ba09 100644 --- a/proxy/vmess/outbound/outbound.go +++ b/proxy/vmess/outbound/outbound.go @@ -34,6 +34,7 @@ func (this *VMessOutboundHandler) Dispatch(firstPacket v2net.Packet, ray ray.Out User: vNextUser, Command: command, Address: firstPacket.Destination().Address(), + Port: firstPacket.Destination().Port(), } buffer := alloc.NewSmallBuffer() @@ -46,8 +47,21 @@ func (this *VMessOutboundHandler) Dispatch(firstPacket v2net.Packet, ray ray.Out return startCommunicate(request, vNextAddress, ray, firstPacket) } -func startCommunicate(request *protocol.VMessRequest, dest v2net.Address, ray ray.OutboundRay, firstPacket v2net.Packet) error { - conn, err := net.Dial("tcp", dest.String()) +func startCommunicate(request *protocol.VMessRequest, dest v2net.Destination, ray ray.OutboundRay, firstPacket v2net.Packet) error { + var destIp net.IP + if dest.Address().IsIPv4() || dest.Address().IsIPv6() { + destIp = dest.Address().IP() + } else { + ips, err := net.LookupIP(dest.Address().Domain()) + if err != nil { + return err + } + destIp = ips[0] + } + conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{ + IP: destIp, + Port: int(dest.Port()), + }) if err != nil { log.Error("Failed to open %s: %v", dest.String(), err) if ray != nil { @@ -69,9 +83,7 @@ func startCommunicate(request *protocol.VMessRequest, dest v2net.Address, ray ra go handleResponse(conn, request, output, &responseFinish, (request.Command == protocol.CmdUDP)) requestFinish.Lock() - if tcpConn, ok := conn.(*net.TCPConn); ok { - tcpConn.CloseWrite() - } + conn.CloseWrite() responseFinish.Lock() return nil } diff --git a/proxy/vmess/outbound/receiver.go b/proxy/vmess/outbound/receiver.go index 6703a805a..a504b48c4 100644 --- a/proxy/vmess/outbound/receiver.go +++ b/proxy/vmess/outbound/receiver.go @@ -8,8 +8,8 @@ import ( ) type Receiver struct { - Address v2net.Address - Accounts []vmess.User + Destination v2net.Destination + Accounts []vmess.User } type ReceiverManager struct { @@ -22,7 +22,7 @@ func NewReceiverManager(receivers []*Receiver) *ReceiverManager { } } -func (this *ReceiverManager) PickReceiver() (v2net.Address, vmess.User) { +func (this *ReceiverManager) PickReceiver() (v2net.Destination, vmess.User) { receiverLen := len(this.receivers) receiverIdx := 0 if receiverLen > 1 { @@ -37,5 +37,5 @@ func (this *ReceiverManager) PickReceiver() (v2net.Address, vmess.User) { userIdx = rand.Intn(userLen) } user := receiver.Accounts[userIdx] - return receiver.Address, user + return receiver.Destination, user } diff --git a/proxy/vmess/protocol/vmess.go b/proxy/vmess/protocol/vmess.go index bb482acbc..2ea6da1fc 100644 --- a/proxy/vmess/protocol/vmess.go +++ b/proxy/vmess/protocol/vmess.go @@ -41,14 +41,15 @@ type VMessRequest struct { ResponseHeader []byte Command byte Address v2net.Address + Port v2net.Port } // Destination is the final destination of this request. func (this *VMessRequest) Destination() v2net.Destination { if this.Command == CmdTCP { - return v2net.NewTCPDestination(this.Address) + return v2net.TCPDestination(this.Address, this.Port) } else { - return v2net.NewUDPDestination(this.Address) + return v2net.UDPDestination(this.Address, this.Port) } } @@ -106,7 +107,7 @@ func (this *VMessRequestReader) Read(reader io.Reader) (*VMessRequest, error) { request.ResponseHeader = buffer.Value[33:37] // 4 bytes request.Command = buffer.Value[37] - port := v2net.PortFromBytes(buffer.Value[38:40]) + request.Port = v2net.PortFromBytes(buffer.Value[38:40]) switch buffer.Value[40] { case addrTypeIPv4: @@ -115,14 +116,14 @@ func (this *VMessRequestReader) Read(reader io.Reader) (*VMessRequest, error) { if err != nil { return nil, err } - request.Address = v2net.IPAddress(buffer.Value[41:45], port) + request.Address = v2net.IPAddress(buffer.Value[41:45]) case addrTypeIPv6: _, err = v2net.ReadAllBytes(decryptor, buffer.Value[41:57]) // 16 bytes bufferLen += 16 if err != nil { return nil, err } - request.Address = v2net.IPAddress(buffer.Value[41:57], port) + request.Address = v2net.IPAddress(buffer.Value[41:57]) case addrTypeDomain: _, err = v2net.ReadAllBytes(decryptor, buffer.Value[41:42]) if err != nil { @@ -134,7 +135,7 @@ func (this *VMessRequestReader) Read(reader io.Reader) (*VMessRequest, error) { return nil, err } bufferLen += 1 + domainLength - request.Address = v2net.DomainAddress(string(buffer.Value[42:42+domainLength]), port) + request.Address = v2net.DomainAddress(string(buffer.Value[42 : 42+domainLength])) } _, err = v2net.ReadAllBytes(decryptor, buffer.Value[bufferLen:bufferLen+4]) @@ -172,7 +173,7 @@ func (this *VMessRequest) ToBytes(idHash user.CounterHash, randomRangeInt64 user buffer.Append(this.RequestKey) buffer.Append(this.ResponseHeader) buffer.AppendBytes(this.Command) - buffer.Append(this.Address.Port().Bytes()) + buffer.Append(this.Port.Bytes()) switch { case this.Address.IsIPv4(): diff --git a/proxy/vmess/protocol/vmess_test.go b/proxy/vmess/protocol/vmess_test.go index 46826aac4..d56ef85c8 100644 --- a/proxy/vmess/protocol/vmess_test.go +++ b/proxy/vmess/protocol/vmess_test.go @@ -55,7 +55,8 @@ func TestVMessSerialization(t *testing.T) { request.ResponseHeader = randBytes[32:] request.Command = byte(0x01) - request.Address = v2net.DomainAddress("v2ray.com", 80) + request.Address = v2net.DomainAddress("v2ray.com") + request.Port = v2net.Port(80) mockTime := int64(1823730) @@ -113,7 +114,8 @@ func BenchmarkVMessRequestWriting(b *testing.B) { request.ResponseHeader = randBytes[32:] request.Command = byte(0x01) - request.Address = v2net.DomainAddress("v2ray.com", 80) + request.Address = v2net.DomainAddress("v2ray.com") + request.Port = v2net.Port(80) for i := 0; i < b.N; i++ { request.ToBytes(user.NewTimeHash(user.HMACHash{}), user.GenerateRandomInt64InRange, nil) diff --git a/proxy/vmess/vmess_test.go b/proxy/vmess/vmess_test.go index 64ec1e9db..6865270bd 100644 --- a/proxy/vmess/vmess_test.go +++ b/proxy/vmess/vmess_test.go @@ -52,7 +52,7 @@ func TestVMessInAndOut(t *testing.T) { SettingsValue: &outboundjson.Outbound{ []*outboundjson.ConfigTarget{ &outboundjson.ConfigTarget{ - Address: v2net.IPAddress([]byte{127, 0, 0, 1}, portB), + Destination: v2net.TCPDestination(v2net.IPAddress([]byte{127, 0, 0, 1}), portB), Users: []*vmessjson.ConfigUser{ &vmessjson.ConfigUser{Id: testAccount}, }, @@ -99,7 +99,7 @@ func TestVMessInAndOut(t *testing.T) { err = pointB.Start() assert.Error(err).IsNil() - dest := v2net.NewTCPDestination(v2net.IPAddress([]byte{1, 2, 3, 4}, 80)) + dest := v2net.TCPDestination(v2net.IPAddress([]byte{1, 2, 3, 4}), 80) ich.Communicate(v2net.NewPacket(dest, nil, true)) assert.Bytes(ichConnInput).Equals(ochConnOutput.Bytes()) assert.Bytes(ichConnOutput.Bytes()).Equals(ochConnInput) diff --git a/testing/scenarios/socks5_helper.go b/testing/scenarios/socks5_helper.go index 0faceb705..96325b47f 100644 --- a/testing/scenarios/socks5_helper.go +++ b/testing/scenarios/socks5_helper.go @@ -29,20 +29,21 @@ func appendAddress(request []byte, address v2net.Address) []byte { request = append(request, []byte(address.Domain())...) } + return request +} + +func socks5Request(command byte, address v2net.Destination) []byte { + request := []byte{socks5Version, command, 0} + request = appendAddress(request, address.Address()) request = append(request, address.Port().Bytes()...) return request } -func socks5Request(command byte, address v2net.Address) []byte { - request := []byte{socks5Version, command, 0} - request = appendAddress(request, address) - return request -} - -func socks5UDPRequest(address v2net.Address, payload []byte) []byte { +func socks5UDPRequest(address v2net.Destination, payload []byte) []byte { request := make([]byte, 0, 1024) request = append(request, 0, 0, 0) - request = appendAddress(request, address) + request = appendAddress(request, address.Address()) + request = append(request, address.Port().Bytes()...) request = append(request, payload...) return request } diff --git a/testing/scenarios/socks_end_test.go b/testing/scenarios/socks_end_test.go index cc6353525..e0a36c95b 100644 --- a/testing/scenarios/socks_end_test.go +++ b/testing/scenarios/socks_end_test.go @@ -53,7 +53,7 @@ func TestTCPConnection(t *testing.T) { assert.Error(err).IsNil() assert.Bytes(authResponse[:nBytes]).Equals([]byte{socks5Version, 0}) - connectRequest := socks5Request(byte(1), v2net.IPAddress([]byte{127, 0, 0, 1}, targetPort)) + connectRequest := socks5Request(byte(1), v2net.TCPDestination(v2net.IPAddress([]byte{127, 0, 0, 1}), targetPort)) nBytes, err = conn.Write(connectRequest) assert.Int(nBytes).Equals(len(connectRequest)) assert.Error(err).IsNil() @@ -124,7 +124,7 @@ func TestTCPBind(t *testing.T) { assert.Error(err).IsNil() assert.Bytes(authResponse[:nBytes]).Equals([]byte{socks5Version, 0}) - connectRequest := socks5Request(byte(2), v2net.IPAddress([]byte{127, 0, 0, 1}, targetPort)) + connectRequest := socks5Request(byte(2), v2net.TCPDestination(v2net.IPAddress([]byte{127, 0, 0, 1}), targetPort)) nBytes, err = conn.Write(connectRequest) assert.Int(nBytes).Equals(len(connectRequest)) assert.Error(err).IsNil() @@ -173,7 +173,7 @@ func TestUDPAssociate(t *testing.T) { assert.Error(err).IsNil() assert.Bytes(authResponse[:nBytes]).Equals([]byte{socks5Version, 0}) - connectRequest := socks5Request(byte(3), v2net.IPAddress([]byte{127, 0, 0, 1}, targetPort)) + connectRequest := socks5Request(byte(3), v2net.TCPDestination(v2net.IPAddress([]byte{127, 0, 0, 1}), targetPort)) nBytes, err = conn.Write(connectRequest) assert.Int(nBytes).Equals(len(connectRequest)) assert.Error(err).IsNil() @@ -190,7 +190,7 @@ func TestUDPAssociate(t *testing.T) { assert.Error(err).IsNil() udpPayload := "UDP request to udp server." - udpRequest := socks5UDPRequest(v2net.IPAddress([]byte{127, 0, 0, 1}, targetPort), []byte(udpPayload)) + udpRequest := socks5UDPRequest(v2net.UDPDestination(v2net.IPAddress([]byte{127, 0, 0, 1}), targetPort), []byte(udpPayload)) nBytes, err = udpConn.Write(udpRequest) assert.Int(nBytes).Equals(len(udpRequest)) @@ -200,7 +200,7 @@ func TestUDPAssociate(t *testing.T) { nBytes, err = udpConn.Read(udpResponse) assert.Error(err).IsNil() assert.Bytes(udpResponse[:nBytes]).Equals( - socks5UDPRequest(v2net.IPAddress([]byte{127, 0, 0, 1}, targetPort), []byte("Processed: UDP request to udp server."))) + socks5UDPRequest(v2net.UDPDestination(v2net.IPAddress([]byte{127, 0, 0, 1}), targetPort), []byte("Processed: UDP request to udp server."))) udpConn.Close() conn.Close() diff --git a/testing/servers/tcp/tcp.go b/testing/servers/tcp/tcp.go index 0ebea452b..ed2e36c9c 100644 --- a/testing/servers/tcp/tcp.go +++ b/testing/servers/tcp/tcp.go @@ -13,7 +13,7 @@ type Server struct { accepting bool } -func (server *Server) Start() (v2net.Address, error) { +func (server *Server) Start() (v2net.Destination, error) { listener, err := net.ListenTCP("tcp", &net.TCPAddr{ IP: []byte{0, 0, 0, 0}, Port: int(server.Port), @@ -24,7 +24,7 @@ func (server *Server) Start() (v2net.Address, error) { } go server.acceptConnections(listener) localAddr := listener.Addr().(*net.TCPAddr) - return v2net.IPAddress(localAddr.IP, v2net.Port(localAddr.Port)), nil + return v2net.TCPDestination(v2net.IPAddress(localAddr.IP), v2net.Port(localAddr.Port)), nil } func (server *Server) acceptConnections(listener *net.TCPListener) { diff --git a/testing/servers/udp/udp.go b/testing/servers/udp/udp.go index 911992551..4b0828bfc 100644 --- a/testing/servers/udp/udp.go +++ b/testing/servers/udp/udp.go @@ -13,7 +13,7 @@ type Server struct { accepting bool } -func (server *Server) Start() (v2net.Address, error) { +func (server *Server) Start() (v2net.Destination, error) { conn, err := net.ListenUDP("udp", &net.UDPAddr{ IP: []byte{0, 0, 0, 0}, Port: int(server.Port), @@ -24,7 +24,7 @@ func (server *Server) Start() (v2net.Address, error) { } go server.handleConnection(conn) localAddr := conn.LocalAddr().(*net.UDPAddr) - return v2net.IPAddress(localAddr.IP, v2net.Port(localAddr.Port)), nil + return v2net.UDPDestination(v2net.IPAddress(localAddr.IP), v2net.Port(localAddr.Port)), nil } func (server *Server) handleConnection(conn *net.UDPConn) {