mirrors/hysteria
1
0
Fork 0
mirror of https://github.com/apernet/hysteria.git synced 2025-04-04 21:17:47 +03:00
Code Issues Projects Releases Packages Wiki Activity

Split host & port in the protocol, and make each domain resolves only once even when ACL is enabled, improving performance and ensuring consistency of connection destinations

Browse source
This commit is contained in:
Toby 2021-04-19 00:20:22 -07:00
parent 7b841aa203
commit b09880a050
8 changed files with 196 additions and 136 deletions
Download patch file Download diff file Expand all files Collapse all files

40
pkg/acl/engine.go
View file

@ -52,39 +52,47 @@ func LoadFromFile(filename string) (*Engine, error) {
}, nil }, nil
} }
func (e *Engine) Lookup(domain string, ip net.IP) (Action, string) { func (e *Engine) ResolveAndMatch(host string) (Action, string, *net.IPAddr, error) {
if len(domain) > 0 { ip, zone := parseIPZone(host)
if ip == nil {
// Domain // Domain
if v, ok := e.Cache.Get(domain); ok { ipAddr, err := net.ResolveIPAddr("ip", host)
if v, ok := e.Cache.Get(host); ok {
// Cache hit // Cache hit
ce := v.(cacheEntry) ce := v.(cacheEntry)
return ce.Action, ce.Arg return ce.Action, ce.Arg, ipAddr, err
} }
ips, _ := net.LookupIP(domain)
for _, entry := range e.Entries { for _, entry := range e.Entries {
if entry.MatchDomain(domain) || (len(ips) > 0 && entry.MatchIPs(ips)) { if entry.MatchDomain(host) || (ipAddr != nil && entry.MatchIP(ipAddr.IP)) {
e.Cache.Add(domain, cacheEntry{entry.Action, entry.ActionArg}) e.Cache.Add(host, cacheEntry{entry.Action, entry.ActionArg})
return entry.Action, entry.ActionArg return entry.Action, entry.ActionArg, ipAddr, err
} }
} }
e.Cache.Add(domain, cacheEntry{e.DefaultAction, ""}) e.Cache.Add(host, cacheEntry{e.DefaultAction, ""})
return e.DefaultAction, "" return e.DefaultAction, "", ipAddr, err
} else if ip != nil { } else {
// IP // IP
if v, ok := e.Cache.Get(ip.String()); ok { if v, ok := e.Cache.Get(ip.String()); ok {
// Cache hit // Cache hit
ce := v.(cacheEntry) ce := v.(cacheEntry)
return ce.Action, ce.Arg return ce.Action, ce.Arg, &net.IPAddr{
IP: ip,
Zone: zone,
}, nil
} }
for _, entry := range e.Entries { for _, entry := range e.Entries {
if entry.MatchIP(ip) { if entry.MatchIP(ip) {
e.Cache.Add(ip.String(), cacheEntry{entry.Action, entry.ActionArg}) e.Cache.Add(ip.String(), cacheEntry{entry.Action, entry.ActionArg})
return entry.Action, entry.ActionArg return entry.Action, entry.ActionArg, &net.IPAddr{
IP: ip,
Zone: zone,
}, nil
} }
} }
e.Cache.Add(ip.String(), cacheEntry{e.DefaultAction, ""}) e.Cache.Add(ip.String(), cacheEntry{e.DefaultAction, ""})
return e.DefaultAction, "" return e.DefaultAction, "", &net.IPAddr{
} else { IP: ip,
return e.DefaultAction, "" Zone: zone,
}, nil
} }
} }

58
pkg/acl/engine_test.go
View file

@ -6,7 +6,7 @@ import (
"testing" "testing"
) )
func TestEngine_Lookup(t *testing.T) { func TestEngine_ResolveAndMatch(t *testing.T) {
cache, _ := lru.NewARC(4) cache, _ := lru.NewARC(4)
e := &Engine{ e := &Engine{
DefaultAction: ActionDirect, DefaultAction: ActionDirect,
@ -49,61 +49,65 @@ func TestEngine_Lookup(t *testing.T) {
}, },
Cache: cache, Cache: cache,
} }
type args struct {
domain string
ip net.IP
}
tests := []struct { tests := []struct {
name string name string
args args addr string
want Action want Action
want1 string want1 string
wantErr bool
}{ }{
{ {
name: "domain direct", name: "domain direct",
args: args{"google.com", nil}, addr: "google.com",
want: ActionProxy, want: ActionProxy,
want1: "", want1: "",
}, },
{ {
name: "domain suffix 1", name: "domain suffix 1",
args: args{"evil.corp", nil}, addr: "evil.corp",
want: ActionHijack, want: ActionHijack,
want1: "good.org", want1: "good.org",
wantErr: true,
}, },
{ {
name: "domain suffix 2", name: "domain suffix 2",
args: args{"notevil.corp", nil}, addr: "notevil.corp",
want: ActionBlock, want: ActionBlock,
want1: "", want1: "",
wantErr: true,
}, },
{ {
name: "domain suffix 3", name: "domain suffix 3",
args: args{"im.real.evil.corp", nil}, addr: "im.real.evil.corp",
want: ActionHijack, want: ActionHijack,
want1: "good.org", want1: "good.org",
wantErr: true,
}, },
{ {
name: "ip match", name: "ip match",
args: args{"", net.ParseIP("10.2.3.4")}, addr: "10.2.3.4",
want: ActionProxy, want: ActionProxy,
want1: "", want1: "",
}, },
{ {
name: "ip mismatch", name: "ip mismatch",
args: args{"", net.ParseIP("100.5.6.0")}, addr: "100.5.6.0",
want: ActionBlock, want: ActionBlock,
want1: "", want1: "",
}, },
} }
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
got, got1 := e.Lookup(tt.args.domain, tt.args.ip) got, got1, _, err := e.ResolveAndMatch(tt.addr)
if (err != nil) != tt.wantErr {
t.Errorf("ResolveAndMatch() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != tt.want { if got != tt.want {
t.Errorf("Lookup() got = %v, want %v", got, tt.want) t.Errorf("ResolveAndMatch() got = %v, want %v", got, tt.want)
} }
if got1 != tt.want1 { if got1 != tt.want1 {
t.Errorf("Lookup() got1 = %v, want %v", got1, tt.want1) t.Errorf("ResolveAndMatch() got1 = %v, want %v", got1, tt.want1)
} }
}) })
} }

14
pkg/acl/entry.go
View file

@ -50,20 +50,6 @@ func (e Entry) MatchIP(ip net.IP) bool {
return false return false
} }
func (e Entry) MatchIPs(ips []net.IP) bool {
if e.All {
return true
}
if e.Net != nil && len(ips) > 0 {
for _, ip := range ips {
if e.Net.Contains(ip) {
return true
}
}
}
return false
}
// Format: action cond_type cond arg // Format: action cond_type cond arg
// Examples: // Examples:
// proxy domain-suffix google.com // proxy domain-suffix google.com

31
pkg/core/client.go
View file

@ -10,6 +10,7 @@ import (
"github.com/lucas-clemente/quic-go/congestion" "github.com/lucas-clemente/quic-go/congestion"
"github.com/lunixbochs/struc" "github.com/lunixbochs/struc"
"net" "net"
"strconv"
"sync" "sync"
"time" "time"
) )
@ -187,14 +188,19 @@ func (c *Client) openStreamWithReconnect() (quic.Session, quic.Stream, error) {
} }
func (c *Client) DialTCP(addr string) (net.Conn, error) { func (c *Client) DialTCP(addr string) (net.Conn, error) {
host, port, err := splitHostPort(addr)
if err != nil {
return nil, err
}
session, stream, err := c.openStreamWithReconnect() session, stream, err := c.openStreamWithReconnect()
if err != nil { if err != nil {
return nil, err return nil, err
} }
// Send request // Send request
err = struc.Pack(stream, &clientRequest{ err = struc.Pack(stream, &clientRequest{
UDP: false, UDP: false,
Address: addr, Host: host,
Port: port,
}) })
if err != nil { if err != nil {
_ = stream.Close() _ = stream.Close()
@ -349,14 +355,19 @@ func (c *quicPktConn) ReadFrom() ([]byte, string, error) {
// Closed // Closed
return nil, "", ErrClosed return nil, "", ErrClosed
} }
return msg.Data, msg.Address, nil return msg.Data, net.JoinHostPort(msg.Host, strconv.Itoa(int(msg.Port))), nil
} }
func (c *quicPktConn) WriteTo(p []byte, addr string) error { func (c *quicPktConn) WriteTo(p []byte, addr string) error {
host, port, err := splitHostPort(addr)
if err != nil {
return err
}
var msgBuf bytes.Buffer var msgBuf bytes.Buffer
_ = struc.Pack(&msgBuf, &udpMessage{ _ = struc.Pack(&msgBuf, &udpMessage{
SessionID: c.UDPSessionID, SessionID: c.UDPSessionID,
Address: addr, Host: host,
Port: port,
Data: p, Data: p,
}) })
return c.Session.SendMessage(msgBuf.Bytes()) return c.Session.SendMessage(msgBuf.Bytes())
@ -366,3 +377,15 @@ func (c *quicPktConn) Close() error {
c.CloseFunc() c.CloseFunc()
return c.Stream.Close() return c.Stream.Close()
} }
func splitHostPort(hostport string) (string, uint16, error) {
host, port, err := net.SplitHostPort(hostport)
if err != nil {
return "", 0, err
}
portUint, err := strconv.ParseUint(port, 10, 16)
if err != nil {
return "", 0, err
}
return host, uint16(portUint), err
}

18
pkg/core/protocol.go
View file

@ -32,9 +32,10 @@ type serverHello struct {
} }
type clientRequest struct { type clientRequest struct {
UDP bool UDP bool
AddressLen uint16 `struc:"sizeof=Address"` HostLen uint16 `struc:"sizeof=Host"`
Address string Host string
Port uint16
} }
type serverResponse struct { type serverResponse struct {
@ -45,9 +46,10 @@ type serverResponse struct {
} }
type udpMessage struct { type udpMessage struct {
SessionID uint32 SessionID uint32
AddressLen uint16 `struc:"sizeof=Address"` HostLen uint16 `struc:"sizeof=Host"`
Address string Host string
DataLen uint16 `struc:"sizeof=Data"` Port uint16
Data []byte DataLen uint16 `struc:"sizeof=Data"`
Data []byte
} }

81
pkg/core/server_client.go
View file

@ -10,6 +10,7 @@ import (
"github.com/tobyxdd/hysteria/pkg/acl" "github.com/tobyxdd/hysteria/pkg/acl"
"github.com/tobyxdd/hysteria/pkg/utils" "github.com/tobyxdd/hysteria/pkg/utils"
"net" "net"
"strconv"
"sync" "sync"
) )
@ -88,7 +89,7 @@ func (c *serverClient) handleStream(stream quic.Stream) {
} }
if !req.UDP { if !req.UDP {
// TCP connection // TCP connection
c.handleTCP(stream, req.Address) c.handleTCP(stream, req.Host, req.Port)
} else if !c.DisableUDP { } else if !c.DisableUDP {
// UDP connection // UDP connection
c.handleUDP(stream) c.handleUDP(stream)
@ -112,32 +113,30 @@ func (c *serverClient) handleMessage(msg []byte) {
c.udpSessionMutex.RUnlock() c.udpSessionMutex.RUnlock()
if ok { if ok {
// Session found, send the message // Session found, send the message
host, port, err := net.SplitHostPort(udpMsg.Address) action, arg := acl.ActionDirect, ""
var ipAddr *net.IPAddr
if c.ACLEngine != nil {
action, arg, ipAddr, err = c.ACLEngine.ResolveAndMatch(udpMsg.Host)
} else {
ipAddr, err = net.ResolveIPAddr("ip", udpMsg.Host)
}
if err != nil { if err != nil {
return return
} }
action, arg := acl.ActionDirect, ""
if c.ACLEngine != nil {
ip := net.ParseIP(host)
if ip != nil {
// IP request, clear host for ACL engine
host = ""
}
action, arg = c.ACLEngine.Lookup(host, ip)
}
switch action { switch action {
case acl.ActionDirect, acl.ActionProxy: // Treat proxy as direct on server side case acl.ActionDirect, acl.ActionProxy: // Treat proxy as direct on server side
addr, err := net.ResolveUDPAddr("udp", udpMsg.Address) _, _ = conn.WriteToUDP(udpMsg.Data, &net.UDPAddr{
if err == nil { IP: ipAddr.IP,
_, _ = conn.WriteToUDP(udpMsg.Data, addr) Port: int(udpMsg.Port),
if c.UpCounter != nil { Zone: ipAddr.Zone,
c.UpCounter.Add(float64(len(udpMsg.Data))) })
} if c.UpCounter != nil {
c.UpCounter.Add(float64(len(udpMsg.Data)))
} }
case acl.ActionBlock: case acl.ActionBlock:
// Do nothing // Do nothing
case acl.ActionHijack: case acl.ActionHijack:
hijackAddr := net.JoinHostPort(arg, port) hijackAddr := net.JoinHostPort(arg, strconv.Itoa(int(udpMsg.Port)))
addr, err := net.ResolveUDPAddr("udp", hijackAddr) addr, err := net.ResolveUDPAddr("udp", hijackAddr)
if err == nil { if err == nil {
_, _ = conn.WriteToUDP(udpMsg.Data, addr) _, _ = conn.WriteToUDP(udpMsg.Data, addr)
@ -151,37 +150,40 @@ func (c *serverClient) handleMessage(msg []byte) {
} }
} }
func (c *serverClient) handleTCP(stream quic.Stream, reqAddr string) { func (c *serverClient) handleTCP(stream quic.Stream, host string, port uint16) {
host, port, err := net.SplitHostPort(reqAddr) addrStr := net.JoinHostPort(host, strconv.Itoa(int(port)))
action, arg := acl.ActionDirect, ""
var ipAddr *net.IPAddr
var err error
if c.ACLEngine != nil {
action, arg, ipAddr, err = c.ACLEngine.ResolveAndMatch(host)
} else {
ipAddr, err = net.ResolveIPAddr("ip", host)
}
if err != nil { if err != nil {
_ = struc.Pack(stream, &serverResponse{ _ = struc.Pack(stream, &serverResponse{
OK: false, OK: false,
Message: "invalid address", Message: "host resolution failure",
}) })
c.CTCPErrorFunc(c.ClientAddr, c.Auth, reqAddr, err) c.CTCPErrorFunc(c.ClientAddr, c.Auth, addrStr, err)
return return
} }
action, arg := acl.ActionDirect, "" c.CTCPRequestFunc(c.ClientAddr, c.Auth, addrStr, action, arg)
if c.ACLEngine != nil {
ip := net.ParseIP(host)
if ip != nil {
// IP request, clear host for ACL engine
host = ""
}
action, arg = c.ACLEngine.Lookup(host, ip)
}
c.CTCPRequestFunc(c.ClientAddr, c.Auth, reqAddr, action, arg)
var conn net.Conn // Connection to be piped var conn net.Conn // Connection to be piped
switch action { switch action {
case acl.ActionDirect, acl.ActionProxy: // Treat proxy as direct on server side case acl.ActionDirect, acl.ActionProxy: // Treat proxy as direct on server side
conn, err = net.DialTimeout("tcp", reqAddr, dialTimeout) conn, err = net.DialTCP("tcp", nil, &net.TCPAddr{
IP: ipAddr.IP,
Port: int(port),
Zone: ipAddr.Zone,
})
if err != nil { if err != nil {
_ = struc.Pack(stream, &serverResponse{ _ = struc.Pack(stream, &serverResponse{
OK: false, OK: false,
Message: err.Error(), Message: err.Error(),
}) })
c.CTCPErrorFunc(c.ClientAddr, c.Auth, reqAddr, err) c.CTCPErrorFunc(c.ClientAddr, c.Auth, addrStr, err)
return return
} }
case acl.ActionBlock: case acl.ActionBlock:
@ -191,14 +193,14 @@ func (c *serverClient) handleTCP(stream quic.Stream, reqAddr string) {
}) })
return return
case acl.ActionHijack: case acl.ActionHijack:
hijackAddr := net.JoinHostPort(arg, port) hijackAddr := net.JoinHostPort(arg, strconv.Itoa(int(port)))
conn, err = net.DialTimeout("tcp", hijackAddr, dialTimeout) conn, err = net.Dial("tcp", hijackAddr)
if err != nil { if err != nil {
_ = struc.Pack(stream, &serverResponse{ _ = struc.Pack(stream, &serverResponse{
OK: false, OK: false,
Message: err.Error(), Message: err.Error(),
}) })
c.CTCPErrorFunc(c.ClientAddr, c.Auth, reqAddr, err) c.CTCPErrorFunc(c.ClientAddr, c.Auth, addrStr, err)
return return
} }
default: default:
@ -227,7 +229,7 @@ func (c *serverClient) handleTCP(stream quic.Stream, reqAddr string) {
} else { } else {
err = utils.Pipe2Way(stream, conn, nil) err = utils.Pipe2Way(stream, conn, nil)
} }
c.CTCPErrorFunc(c.ClientAddr, c.Auth, reqAddr, err) c.CTCPErrorFunc(c.ClientAddr, c.Auth, addrStr, err)
} }
func (c *serverClient) handleUDP(stream quic.Stream) { func (c *serverClient) handleUDP(stream quic.Stream) {
@ -268,7 +270,8 @@ func (c *serverClient) handleUDP(stream quic.Stream) {
var msgBuf bytes.Buffer var msgBuf bytes.Buffer
_ = struc.Pack(&msgBuf, &udpMessage{ _ = struc.Pack(&msgBuf, &udpMessage{
SessionID: id, SessionID: id,
Address: rAddr.String(), Host: rAddr.IP.String(),
Port: uint16(rAddr.Port),
Data: buf[:n], Data: buf[:n],
}) })
_ = c.CS.SendMessage(msgBuf.Bytes()) _ = c.CS.SendMessage(msgBuf.Bytes())

23
pkg/http/server.go
View file

@ -5,6 +5,7 @@ import (
"fmt" "fmt"
"net" "net"
"net/http" "net/http"
"strconv"
"time" "time"
"github.com/elazarl/goproxy/ext/auth" "github.com/elazarl/goproxy/ext/auth"
@ -27,20 +28,30 @@ func NewProxyHTTPServer(hyClient *core.Client, idleTimeout time.Duration, aclEng
if err != nil { if err != nil {
return nil, err return nil, err
} }
portUint, err := strconv.ParseUint(port, 10, 16)
if err != nil {
return nil, err
}
// ACL // ACL
action, arg := acl.ActionProxy, "" action, arg := acl.ActionProxy, ""
var ipAddr *net.IPAddr
var resErr error
if aclEngine != nil { if aclEngine != nil {
ip := net.ParseIP(host) action, arg, ipAddr, resErr = aclEngine.ResolveAndMatch(host)
if ip != nil { // Doesn't always matter if the resolution fails, as we may send it through HyClient
host = ""
}
action, arg = aclEngine.Lookup(host, ip)
} }
newDialFunc(addr, action, arg) newDialFunc(addr, action, arg)
// Handle according to the action // Handle according to the action
switch action { switch action {
case acl.ActionDirect: case acl.ActionDirect:
return net.Dial(network, addr) if resErr != nil {
return nil, resErr
}
return net.DialTCP(network, nil, &net.TCPAddr{
IP: ipAddr.IP,
Port: int(portUint),
Zone: ipAddr.Zone,
})
case acl.ActionProxy: case acl.ActionProxy:
return hyClient.DialTCP(addr) return hyClient.DialTCP(addr)
case acl.ActionBlock: case acl.ActionBlock:

67
pkg/socks5/server.go
View file

@ -162,10 +162,13 @@ func (s *Server) handle(c *net.TCPConn, r *socks5.Request) error {
} }
func (s *Server) handleTCP(c *net.TCPConn, r *socks5.Request) error { func (s *Server) handleTCP(c *net.TCPConn, r *socks5.Request) error {
domain, ip, port, addr := parseRequestAddress(r) host, port, addr := parseRequestAddress(r)
action, arg := acl.ActionProxy, "" action, arg := acl.ActionProxy, ""
var ipAddr *net.IPAddr
var resErr error
if s.ACLEngine != nil { if s.ACLEngine != nil {
action, arg = s.ACLEngine.Lookup(domain, ip) action, arg, ipAddr, resErr = s.ACLEngine.ResolveAndMatch(host)
// Doesn't always matter if the resolution fails, as we may send it through HyClient
} }
s.TCPRequestFunc(c.RemoteAddr(), addr, action, arg) s.TCPRequestFunc(c.RemoteAddr(), addr, action, arg)
var closeErr error var closeErr error
@ -175,7 +178,16 @@ func (s *Server) handleTCP(c *net.TCPConn, r *socks5.Request) error {
// Handle according to the action // Handle according to the action
switch action { switch action {
case acl.ActionDirect: case acl.ActionDirect:
rc, err := net.Dial("tcp", addr) if resErr != nil {
_ = sendReply(c, socks5.RepHostUnreachable)
closeErr = resErr
return resErr
}
rc, err := net.DialTCP("tcp", nil, &net.TCPAddr{
IP: ipAddr.IP,
Port: int(port),
Zone: ipAddr.Zone,
})
if err != nil { if err != nil {
_ = sendReply(c, socks5.RepHostUnreachable) _ = sendReply(c, socks5.RepHostUnreachable)
closeErr = err closeErr = err
@ -201,7 +213,7 @@ func (s *Server) handleTCP(c *net.TCPConn, r *socks5.Request) error {
closeErr = errors.New("blocked in ACL") closeErr = errors.New("blocked in ACL")
return nil return nil
case acl.ActionHijack: case acl.ActionHijack:
rc, err := net.Dial("tcp", net.JoinHostPort(arg, port)) rc, err := net.Dial("tcp", net.JoinHostPort(arg, strconv.Itoa(int(port))))
if err != nil { if err != nil {
_ = sendReply(c, socks5.RepHostUnreachable) _ = sendReply(c, socks5.RepHostUnreachable)
closeErr = err closeErr = err
@ -299,13 +311,15 @@ func (s *Server) udpServer(clientConn *net.UDPConn, localRelayConn *net.UDPConn,
// Start remote to local // Start remote to local
go func() { go func() {
for { for {
bs, _, err := hyUDP.ReadFrom() bs, from, err := hyUDP.ReadFrom()
if err != nil { if err != nil {
break break
} }
// RFC 1928 is very ambiguous on how to properly use DST.ADDR and DST.PORT in reply packets atyp, addr, port, err := socks5.ParseAddress(from)
// So we just fill in zeros for now. Works fine for all the SOCKS5 clients I tested if err != nil {
d := socks5.NewDatagram(socks5.ATYPIPv4, []byte{0x00, 0x00, 0x00, 0x00}, []byte{0x00, 0x00}, bs) continue
}
d := socks5.NewDatagram(atyp, addr, port, bs)
_, _ = clientConn.WriteToUDP(d.Bytes(), clientAddr) _, _ = clientConn.WriteToUDP(d.Bytes(), clientAddr)
} }
}() }()
@ -329,24 +343,31 @@ func (s *Server) udpServer(clientConn *net.UDPConn, localRelayConn *net.UDPConn,
// Not our client, bye // Not our client, bye
continue continue
} }
domain, ip, port, addr := parseDatagramRequestAddress(d) host, port, addr := parseDatagramRequestAddress(d)
action, arg := acl.ActionProxy, "" action, arg := acl.ActionProxy, ""
var ipAddr *net.IPAddr
var resErr error
if s.ACLEngine != nil && localRelayConn != nil { if s.ACLEngine != nil && localRelayConn != nil {
action, arg = s.ACLEngine.Lookup(domain, ip) action, arg, ipAddr, resErr = s.ACLEngine.ResolveAndMatch(host)
// Doesn't always matter if the resolution fails, as we may send it through HyClient
} }
// Handle according to the action // Handle according to the action
switch action { switch action {
case acl.ActionDirect: case acl.ActionDirect:
rAddr, err := net.ResolveUDPAddr("udp", addr) if resErr != nil {
if err == nil { return
_, _ = localRelayConn.WriteToUDP(d.Data, rAddr)
} }
_, _ = localRelayConn.WriteToUDP(d.Data, &net.UDPAddr{
IP: ipAddr.IP,
Port: int(port),
Zone: ipAddr.Zone,
})
case acl.ActionProxy: case acl.ActionProxy:
_ = hyUDP.WriteTo(d.Data, addr) _ = hyUDP.WriteTo(d.Data, addr)
case acl.ActionBlock: case acl.ActionBlock:
// Do nothing // Do nothing
case acl.ActionHijack: case acl.ActionHijack:
hijackAddr := net.JoinHostPort(arg, port) hijackAddr := net.JoinHostPort(arg, net.JoinHostPort(arg, strconv.Itoa(int(port))))
rAddr, err := net.ResolveUDPAddr("udp", hijackAddr) rAddr, err := net.ResolveUDPAddr("udp", hijackAddr)
if err == nil { if err == nil {
_, _ = localRelayConn.WriteToUDP(d.Data, rAddr) _, _ = localRelayConn.WriteToUDP(d.Data, rAddr)
@ -363,22 +384,24 @@ func sendReply(conn *net.TCPConn, rep byte) error {
return err return err
} }
func parseRequestAddress(r *socks5.Request) (domain string, ip net.IP, port string, addr string) { func parseRequestAddress(r *socks5.Request) (host string, port uint16, addr string) {
p := strconv.Itoa(int(binary.BigEndian.Uint16(r.DstPort))) p := binary.BigEndian.Uint16(r.DstPort)
if r.Atyp == socks5.ATYPDomain { if r.Atyp == socks5.ATYPDomain {
d := string(r.DstAddr[1:]) d := string(r.DstAddr[1:])
return d, nil, p, net.JoinHostPort(d, p) return d, p, net.JoinHostPort(d, strconv.Itoa(int(p)))
} else { } else {
return "", r.DstAddr, p, net.JoinHostPort(net.IP(r.DstAddr).String(), p) ipStr := net.IP(r.DstAddr).String()
return ipStr, p, net.JoinHostPort(ipStr, strconv.Itoa(int(p)))
} }
} }
func parseDatagramRequestAddress(r *socks5.Datagram) (domain string, ip net.IP, port string, addr string) { func parseDatagramRequestAddress(r *socks5.Datagram) (host string, port uint16, addr string) {
p := strconv.Itoa(int(binary.BigEndian.Uint16(r.DstPort))) p := binary.BigEndian.Uint16(r.DstPort)
if r.Atyp == socks5.ATYPDomain { if r.Atyp == socks5.ATYPDomain {
d := string(r.DstAddr[1:]) d := string(r.DstAddr[1:])
return d, nil, p, net.JoinHostPort(d, p) return d, p, net.JoinHostPort(d, strconv.Itoa(int(p)))
} else { } else {
return "", r.DstAddr, p, net.JoinHostPort(net.IP(r.DstAddr).String(), p) ipStr := net.IP(r.DstAddr).String()
return ipStr, p, net.JoinHostPort(ipStr, strconv.Itoa(int(p)))
} }
} }