bughz/glider
1
0
Fork 0
mirror of https://github.com/nadoo/glider.git synced 2025-11-04 07:42:38 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

general: combine cdialer and sdialer

Browse Source
This commit is contained in:
nadoo 2018-03-24 19:55:06 +08:00
parent 6e32720c1c
commit f785fa9d6c
13 changed files with 115 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
dialer.go
View File

@ -23,7 +23,7 @@ type Dialer interface {
// DialerFromURL parses url and get a Proxy // DialerFromURL parses url and get a Proxy
// TODO: table // TODO: table
func DialerFromURL(s string, cDialer Dialer) (Dialer, error) { func DialerFromURL(s string, dialer Dialer) (Dialer, error) {
u, err := url.Parse(s) u, err := url.Parse(s)
if err != nil { if err != nil {
logf("parse err: %s", err) logf("parse err: %s", err)
@ -37,17 +37,17 @@ func DialerFromURL(s string, cDialer Dialer) (Dialer, error) {
pass, _ = u.User.Password() pass, _ = u.User.Password()
} }
if cDialer == nil { if dialer == nil {
cDialer = Direct dialer = Direct
} }
switch u.Scheme { switch u.Scheme {
case "http": case "http":
return NewHTTP(addr, user, pass, "", cDialer, nil) return NewHTTP(addr, user, pass, "", dialer)
case "socks5": case "socks5":
return NewSOCKS5(addr, user, pass, cDialer, nil) return NewSOCKS5(addr, user, pass, dialer)
case "ss": case "ss":
return NewSS(addr, user, pass, cDialer, nil) return NewSS(addr, user, pass, dialer)
} }
return nil, errors.New("unknown schema '" + u.Scheme + "'") return nil, errors.New("unknown schema '" + u.Scheme + "'")

12
dns.go
View File

@ -139,8 +139,8 @@ type DNSAnswerHandler func(Domain, ip string) error
// DNS . // DNS .
type DNS struct { type DNS struct {
*Forwarder // as proxy client dialer Dialer
sDialer Dialer // dialer for server addr string
Tunnel bool Tunnel bool
@ -151,10 +151,10 @@ type DNS struct {
} }
// NewDNS returns a dns forwarder. client[dns.udp] -> glider[tcp] -> forwarder[dns.tcp] -> remote dns addr // NewDNS returns a dns forwarder. client[dns.udp] -> glider[tcp] -> forwarder[dns.tcp] -> remote dns addr
func NewDNS(addr, raddr string, sDialer Dialer, tunnel bool) (*DNS, error) { func NewDNS(addr, raddr string, dialer Dialer, tunnel bool) (*DNS, error) {
s := &DNS{ s := &DNS{
Forwarder: NewForwarder(addr, nil), dialer: dialer,
sDialer: sDialer, addr: addr,
Tunnel: tunnel, Tunnel: tunnel,
@ -293,7 +293,7 @@ func (s *DNS) Exchange(reqLen uint16, reqMsg []byte, addr string) (respLen uint1
dnsServer = s.GetServer(query.QNAME) dnsServer = s.GetServer(query.QNAME)
} }
rc, err := s.sDialer.NextDialer(query.QNAME+":53").Dial("tcp", dnsServer) rc, err := s.dialer.NextDialer(query.QNAME+":53").Dial("tcp", dnsServer)
if err != nil { if err != nil {
logf("proxy-dns failed to connect to server %v: %v", dnsServer, err) logf("proxy-dns failed to connect to server %v: %v", dnsServer, err)
return return

12
dnstun.go
View File

@ -4,8 +4,8 @@ package main
// DNSTun struct // DNSTun struct
type DNSTun struct { type DNSTun struct {
*Forwarder // as client dialer Dialer
sDialer Dialer // dialer for server addr string
raddr string raddr string
@ -14,15 +14,15 @@ type DNSTun struct {
} }
// NewDNSTun returns a dns tunnel forwarder. // NewDNSTun returns a dns tunnel forwarder.
func NewDNSTun(addr, raddr string, sDialer Dialer) (*DNSTun, error) { func NewDNSTun(addr, raddr string, dialer Dialer) (*DNSTun, error) {
s := &DNSTun{ s := &DNSTun{
Forwarder: NewForwarder(addr, nil), dialer: dialer,
sDialer: sDialer, addr: addr,
raddr: raddr, raddr: raddr,
} }
s.dns, _ = NewDNS(addr, raddr, sDialer, true) s.dns, _ = NewDNS(addr, raddr, dialer, true)
return s, nil return s, nil
} }

36
forwarder.go
View File

@ -1,36 +0,0 @@
package main
import "net"
// Forwarder struct
type Forwarder struct {
addr string
cDialer Dialer
}
// NewForwarder returns a base forwarder
func NewForwarder(addr string, cDialer Dialer) *Forwarder {
if cDialer == nil {
cDialer = Direct
}
return &Forwarder{addr: addr, cDialer: cDialer}
}
// Addr returns forwarder's address
func (p *Forwarder) Addr() string { return p.addr }
// Dial to remote addr via cDialer
func (p *Forwarder) Dial(network, addr string) (net.Conn, error) {
return p.cDialer.Dial(network, addr)
}
// DialUDP to remote addr via cDialer
func (p *Forwarder) DialUDP(network, addr string) (pc net.PacketConn, writeTo net.Addr, err error) {
return p.cDialer.DialUDP(network, addr)
}
// NextDialer returns the next cDialer
func (p *Forwarder) NextDialer(dstAddr string) Dialer {
return p.cDialer
}

25
http.go
View File

@ -19,9 +19,8 @@ import (
// HTTP struct // HTTP struct
type HTTP struct { type HTTP struct {
*Forwarder // as client dialer Dialer
sDialer Dialer // dialer for server addr string
user string user string
password string password string
xff bool // X-Forwarded-For xff bool // X-Forwarded-For
@ -31,10 +30,10 @@ type HTTP struct {
} }
// NewHTTP returns a http proxy. // NewHTTP returns a http proxy.
func NewHTTP(addr, user, pass, rawQuery string, cDialer Dialer, sDialer Dialer) (*HTTP, error) { func NewHTTP(addr, user, pass, rawQuery string, dialer Dialer) (*HTTP, error) {
s := &HTTP{ s := &HTTP{
Forwarder: NewForwarder(addr, cDialer), dialer: dialer,
sDialer: sDialer, addr: addr,
user: user, user: user,
password: pass, password: pass,
xff: false, xff: false,
@ -129,7 +128,7 @@ func (s *HTTP) Serve(c net.Conn) {
tgt += ":80" tgt += ":80"
} }
rc, err := s.sDialer.Dial("tcp", tgt) rc, err := s.dialer.Dial("tcp", tgt)
if err != nil { if err != nil {
fmt.Fprintf(c, "%s 502 ERROR\r\n\r\n", proto) fmt.Fprintf(c, "%s 502 ERROR\r\n\r\n", proto)
logf("failed to dial: %v", err) logf("failed to dial: %v", err)
@ -189,7 +188,7 @@ func (s *HTTP) Serve(c net.Conn) {
} }
func (s *HTTP) servHTTPS(method, requestURI, proto string, c net.Conn) { func (s *HTTP) servHTTPS(method, requestURI, proto string, c net.Conn) {
rc, err := s.sDialer.Dial("tcp", requestURI) rc, err := s.dialer.Dial("tcp", requestURI)
if err != nil { if err != nil {
c.Write([]byte(proto)) c.Write([]byte(proto))
c.Write([]byte(" 502 ERROR\r\n\r\n")) c.Write([]byte(" 502 ERROR\r\n\r\n"))
@ -199,7 +198,7 @@ func (s *HTTP) servHTTPS(method, requestURI, proto string, c net.Conn) {
c.Write([]byte("HTTP/1.0 200 Connection established\r\n\r\n")) c.Write([]byte("HTTP/1.0 200 Connection established\r\n\r\n"))
logf("proxy-https %s <-> %s", c.RemoteAddr(), requestURI) logf("proxy-http %s <-> %s [connect]", c.RemoteAddr(), requestURI)
_, _, err = relay(c, rc) _, _, err = relay(c, rc)
if err != nil { if err != nil {
@ -210,9 +209,15 @@ func (s *HTTP) servHTTPS(method, requestURI, proto string, c net.Conn) {
} }
} }
// Addr returns forwarder's address
func (s *HTTP) Addr() string { return s.addr }
// NextDialer returns the next dialer
func (s *HTTP) NextDialer(dstAddr string) Dialer { return s.dialer }
// Dial connects to the address addr on the network net via the proxy. // Dial connects to the address addr on the network net via the proxy.
func (s *HTTP) Dial(network, addr string) (net.Conn, error) { func (s *HTTP) Dial(network, addr string) (net.Conn, error) {
rc, err := s.cDialer.Dial(network, s.addr) rc, err := s.dialer.Dial(network, s.addr)
if err != nil { if err != nil {
logf("dial to %s error: %s", s.addr, err) logf("dial to %s error: %s", s.addr, err)
return nil, err return nil, err

10
mixed.go
View File

@ -19,7 +19,7 @@ var httpMethods = [...][]byte{
// MixedProxy struct // MixedProxy struct
type MixedProxy struct { type MixedProxy struct {
sDialer Dialer dialer Dialer
addr string addr string
http *HTTP http *HTTP
@ -27,14 +27,14 @@ type MixedProxy struct {
} }
// NewMixedProxy returns a mixed proxy. // NewMixedProxy returns a mixed proxy.
func NewMixedProxy(addr, user, pass, rawQuery string, sDialer Dialer) (*MixedProxy, error) { func NewMixedProxy(addr, user, pass, rawQuery string, dialer Dialer) (*MixedProxy, error) {
p := &MixedProxy{ p := &MixedProxy{
sDialer: sDialer, dialer: dialer,
addr: addr, addr: addr,
} }
p.http, _ = NewHTTP(addr, user, pass, rawQuery, nil, sDialer) p.http, _ = NewHTTP(addr, user, pass, rawQuery, dialer)
p.socks5, _ = NewSOCKS5(addr, user, pass, nil, sDialer) p.socks5, _ = NewSOCKS5(addr, user, pass, dialer)
return p, nil return p, nil
} }

24
server.go
View File

@ -14,7 +14,7 @@ type Server interface {
// ServerFromURL parses url and get a Proxy // ServerFromURL parses url and get a Proxy
// TODO: table // TODO: table
func ServerFromURL(s string, sDialer Dialer) (Server, error) { func ServerFromURL(s string, dialer Dialer) (Server, error) {
if !strings.Contains(s, "://") { if !strings.Contains(s, "://") {
s = "mixed://" + s s = "mixed://" + s
} }
@ -32,33 +32,33 @@ func ServerFromURL(s string, sDialer Dialer) (Server, error) {
pass, _ = u.User.Password() pass, _ = u.User.Password()
} }
if sDialer == nil { if dialer == nil {
sDialer = Direct dialer = Direct
} }
switch u.Scheme { switch u.Scheme {
case "mixed": case "mixed":
return NewMixedProxy(addr, user, pass, u.RawQuery, sDialer) return NewMixedProxy(addr, user, pass, u.RawQuery, dialer)
case "http": case "http":
return NewHTTP(addr, user, pass, u.RawQuery, nil, sDialer) return NewHTTP(addr, user, pass, u.RawQuery, dialer)
case "socks5": case "socks5":
return NewSOCKS5(addr, user, pass, nil, sDialer) return NewSOCKS5(addr, user, pass, dialer)
case "ss": case "ss":
return NewSS(addr, user, pass, nil, sDialer) return NewSS(addr, user, pass, dialer)
case "redir": case "redir":
return NewRedirProxy(addr, sDialer) return NewRedirProxy(addr, dialer)
case "tcptun": case "tcptun":
d := strings.Split(addr, "=") d := strings.Split(addr, "=")
return NewTCPTun(d[0], d[1], sDialer) return NewTCPTun(d[0], d[1], dialer)
case "udptun": case "udptun":
d := strings.Split(addr, "=") d := strings.Split(addr, "=")
return NewUDPTun(d[0], d[1], sDialer) return NewUDPTun(d[0], d[1], dialer)
case "dnstun": case "dnstun":
d := strings.Split(addr, "=") d := strings.Split(addr, "=")
return NewDNSTun(d[0], d[1], sDialer) return NewDNSTun(d[0], d[1], dialer)
case "uottun": case "uottun":
d := strings.Split(addr, "=") d := strings.Split(addr, "=")
return NewUoTTun(d[0], d[1], sDialer) return NewUoTTun(d[0], d[1], dialer)
} }
return nil, errors.New("unknown schema '" + u.Scheme + "'") return nil, errors.New("unknown schema '" + u.Scheme + "'")

27
socks5.go
View File

@ -62,19 +62,18 @@ var socks5Errors = []error{
// SOCKS5 struct // SOCKS5 struct
type SOCKS5 struct { type SOCKS5 struct {
*Forwarder dialer Dialer
sDialer Dialer addr string
user string user string
password string password string
} }
// NewSOCKS5 returns a Proxy that makes SOCKSv5 connections to the given address // NewSOCKS5 returns a Proxy that makes SOCKSv5 connections to the given address
// with an optional username and password. See RFC 1928. // with an optional username and password. See RFC 1928.
func NewSOCKS5(addr, user, pass string, cDialer Dialer, sDialer Dialer) (*SOCKS5, error) { func NewSOCKS5(addr, user, pass string, dialer Dialer) (*SOCKS5, error) {
s := &SOCKS5{ s := &SOCKS5{
Forwarder: NewForwarder(addr, cDialer), dialer: dialer,
sDialer: sDialer, addr: addr,
user: user, user: user,
password: pass, password: pass,
} }
@ -137,7 +136,7 @@ func (s *SOCKS5) ServeTCP(c net.Conn) {
return return
} }
rc, err := s.sDialer.Dial("tcp", tgt.String()) rc, err := s.dialer.Dial("tcp", tgt.String())
if err != nil { if err != nil {
logf("proxy-socks5 failed to connect to target: %v", err) logf("proxy-socks5 failed to connect to target: %v", err)
return return
@ -186,7 +185,7 @@ func (s *SOCKS5) ListenAndServeUDP() {
continue continue
} }
lpc, nextHop, err := s.sDialer.DialUDP("udp", c.tgtAddr.String()) lpc, nextHop, err := s.dialer.DialUDP("udp", c.tgtAddr.String())
if err != nil { if err != nil {
logf("proxy-socks5-udp remote dial error: %v", err) logf("proxy-socks5-udp remote dial error: %v", err)
continue continue
@ -216,6 +215,12 @@ func (s *SOCKS5) ListenAndServeUDP() {
} }
// Addr returns forwarder's address
func (s *SOCKS5) Addr() string { return s.addr }
// NextDialer returns the next dialer
func (s *SOCKS5) NextDialer(dstAddr string) Dialer { return s.dialer }
// Dial connects to the address addr on the network net via the SOCKS5 proxy. // Dial connects to the address addr on the network net via the SOCKS5 proxy.
func (s *SOCKS5) Dial(network, addr string) (net.Conn, error) { func (s *SOCKS5) Dial(network, addr string) (net.Conn, error) {
switch network { switch network {
@ -224,7 +229,7 @@ func (s *SOCKS5) Dial(network, addr string) (net.Conn, error) {
return nil, errors.New("proxy-socks5: no support for connection type " + network) return nil, errors.New("proxy-socks5: no support for connection type " + network)
} }
c, err := s.cDialer.Dial(network, s.addr) c, err := s.dialer.Dial(network, s.addr)
if err != nil { if err != nil {
logf("dial to %s error: %s", s.addr, err) logf("dial to %s error: %s", s.addr, err)
return nil, err return nil, err
@ -244,7 +249,7 @@ func (s *SOCKS5) Dial(network, addr string) (net.Conn, error) {
// DialUDP connects to the given address via the proxy. // DialUDP connects to the given address via the proxy.
func (s *SOCKS5) DialUDP(network, addr string) (pc net.PacketConn, writeTo net.Addr, err error) { func (s *SOCKS5) DialUDP(network, addr string) (pc net.PacketConn, writeTo net.Addr, err error) {
c, err := s.cDialer.Dial("tcp", s.addr) c, err := s.dialer.Dial("tcp", s.addr)
if err != nil { if err != nil {
logf("proxy-socks5 dialudp dial tcp to %s error: %s", s.addr, err) logf("proxy-socks5 dialudp dial tcp to %s error: %s", s.addr, err)
return nil, nil, err return nil, nil, err
@ -283,7 +288,7 @@ func (s *SOCKS5) DialUDP(network, addr string) (pc net.PacketConn, writeTo net.A
return nil, nil, err return nil, nil, err
} }
pc, nextHop, err := s.cDialer.DialUDP(network, uAddr.String()) pc, nextHop, err := s.dialer.DialUDP(network, uAddr.String())
if err != nil { if err != nil {
logf("proxy-socks5 dialudp to %s error: %s", uAddr.String(), err) logf("proxy-socks5 dialudp to %s error: %s", uAddr.String(), err)
return nil, nil, err return nil, nil, err

24
ss.go
View File

@ -15,22 +15,22 @@ const udpBufSize = 65536
// SS . // SS .
type SS struct { type SS struct {
*Forwarder dialer Dialer
sDialer Dialer addr string
core.Cipher core.Cipher
} }
// NewSS returns a shadowsocks proxy. // NewSS returns a shadowsocks proxy.
func NewSS(addr, method, pass string, cDialer Dialer, sDialer Dialer) (*SS, error) { func NewSS(addr, method, pass string, dialer Dialer) (*SS, error) {
ciph, err := core.PickCipher(method, nil, pass) ciph, err := core.PickCipher(method, nil, pass)
if err != nil { if err != nil {
log.Fatalf("PickCipher for '%s', error: %s", method, err) log.Fatalf("PickCipher for '%s', error: %s", method, err)
} }
s := &SS{ s := &SS{
Forwarder: NewForwarder(addr, cDialer), dialer: dialer,
sDialer: sDialer, addr: addr,
Cipher: ciph, Cipher: ciph,
} }
@ -79,7 +79,7 @@ func (s *SS) ServeTCP(c net.Conn) {
return return
} }
dialer := s.sDialer.NextDialer(tgt.String()) dialer := s.dialer.NextDialer(tgt.String())
// udp over tcp? // udp over tcp?
uot := UoT(tgt[0]) uot := UoT(tgt[0])
@ -166,7 +166,7 @@ func (s *SS) ListenAndServeUDP() {
var pc *PktConn var pc *PktConn
v, ok := nm.Load(raddr.String()) v, ok := nm.Load(raddr.String())
if !ok && v == nil { if !ok && v == nil {
lpc, nextHop, err := s.sDialer.DialUDP("udp", c.tgtAddr.String()) lpc, nextHop, err := s.dialer.DialUDP("udp", c.tgtAddr.String())
if err != nil { if err != nil {
logf("proxy-ss-udp remote dial error: %v", err) logf("proxy-ss-udp remote dial error: %v", err)
continue continue
@ -200,6 +200,12 @@ func ListCipher() string {
return strings.Join(core.ListCipher(), " ") return strings.Join(core.ListCipher(), " ")
} }
// Addr returns forwarder's address
func (s *SS) Addr() string { return s.addr }
// NextDialer returns the next dialer
func (s *SS) NextDialer(dstAddr string) Dialer { return s.dialer }
// Dial connects to the address addr on the network net via the proxy. // Dial connects to the address addr on the network net via the proxy.
func (s *SS) Dial(network, addr string) (net.Conn, error) { func (s *SS) Dial(network, addr string) (net.Conn, error) {
target := ParseAddr(addr) target := ParseAddr(addr)
@ -211,7 +217,7 @@ func (s *SS) Dial(network, addr string) (net.Conn, error) {
target[0] = target[0] | 0x8 target[0] = target[0] | 0x8
} }
c, err := s.cDialer.Dial("tcp", s.addr) c, err := s.dialer.Dial("tcp", s.addr)
if err != nil { if err != nil {
logf("dial to %s error: %s", s.addr, err) logf("dial to %s error: %s", s.addr, err)
return nil, err return nil, err
@ -233,7 +239,7 @@ func (s *SS) Dial(network, addr string) (net.Conn, error) {
// DialUDP connects to the given address via the proxy. // DialUDP connects to the given address via the proxy.
func (s *SS) DialUDP(network, addr string) (net.PacketConn, net.Addr, error) { func (s *SS) DialUDP(network, addr string) (net.PacketConn, net.Addr, error) {
pc, nextHop, err := s.cDialer.DialUDP(network, s.addr) pc, nextHop, err := s.dialer.DialUDP(network, s.addr)
if err != nil { if err != nil {
logf("proxy-ss dialudp to %s error: %s", s.addr, err) logf("proxy-ss dialudp to %s error: %s", s.addr, err)
return nil, nil, err return nil, nil, err

12
tcptun.go
View File

@ -4,17 +4,17 @@ import "net"
// TCPTun struct // TCPTun struct
type TCPTun struct { type TCPTun struct {
*Forwarder dialer Dialer
sDialer Dialer addr string
raddr string raddr string
} }
// NewTCPTun returns a tcptun proxy. // NewTCPTun returns a tcptun proxy.
func NewTCPTun(addr, raddr string, sDialer Dialer) (*TCPTun, error) { func NewTCPTun(addr, raddr string, dialer Dialer) (*TCPTun, error) {
s := &TCPTun{ s := &TCPTun{
Forwarder: NewForwarder(addr, nil), dialer: dialer,
sDialer: sDialer, addr: addr,
raddr: raddr, raddr: raddr,
} }
@ -45,7 +45,7 @@ func (s *TCPTun) ListenAndServe() {
c.SetKeepAlive(true) c.SetKeepAlive(true)
} }
rc, err := s.sDialer.Dial("tcp", s.raddr) rc, err := s.dialer.Dial("tcp", s.raddr)
if err != nil { if err != nil {
logf("failed to connect to target: %v", err) logf("failed to connect to target: %v", err)

10
tproxy.go
View File

@ -17,15 +17,15 @@ import (
// TProxy struct // TProxy struct
type TProxy struct { type TProxy struct {
*Forwarder // as client dialer Dialer
sDialer Dialer // dialer for server addr string
} }
// NewTProxy returns a tproxy. // NewTProxy returns a tproxy.
func NewTProxy(addr string, sDialer Dialer) (*TProxy, error) { func NewTProxy(addr string, dialer Dialer) (*TProxy, error) {
s := &TProxy{ s := &TProxy{
Forwarder: NewForwarder(addr, nil), dialer: dialer,
sDialer: sDialer, addr: addr,
} }
return s, nil return s, nil

12
udptun.go
View File

@ -8,17 +8,17 @@ import (
// UDPTun struct // UDPTun struct
type UDPTun struct { type UDPTun struct {
*Forwarder dialer Dialer
sDialer Dialer addr string
raddr string raddr string
} }
// NewUDPTun returns a UDPTun proxy. // NewUDPTun returns a UDPTun proxy.
func NewUDPTun(addr, raddr string, sDialer Dialer) (*UDPTun, error) { func NewUDPTun(addr, raddr string, dialer Dialer) (*UDPTun, error) {
s := &UDPTun{ s := &UDPTun{
Forwarder: NewForwarder(addr, nil), dialer: dialer,
sDialer: sDialer, addr: addr,
raddr: raddr, raddr: raddr,
} }
@ -52,7 +52,7 @@ func (s *UDPTun) ListenAndServe() {
v, ok := nm.Load(raddr.String()) v, ok := nm.Load(raddr.String())
if !ok && v == nil { if !ok && v == nil {
pc, writeAddr, err = s.sDialer.DialUDP("udp", s.raddr) pc, writeAddr, err = s.dialer.DialUDP("udp", s.raddr)
if err != nil { if err != nil {
logf("proxy-udptun remote dial error: %v", err) logf("proxy-udptun remote dial error: %v", err)
continue continue

12
uottun.go
View File

@ -8,17 +8,17 @@ import (
// UoTTun udp over tcp tunnel // UoTTun udp over tcp tunnel
type UoTTun struct { type UoTTun struct {
*Forwarder dialer Dialer
sDialer Dialer addr string
raddr string raddr string
} }
// NewUoTTun returns a UoTTun proxy. // NewUoTTun returns a UoTTun proxy.
func NewUoTTun(addr, raddr string, sDialer Dialer) (*UoTTun, error) { func NewUoTTun(addr, raddr string, dialer Dialer) (*UoTTun, error) {
s := &UoTTun{ s := &UoTTun{
Forwarder: NewForwarder(addr, nil), dialer: dialer,
sDialer: sDialer, addr: addr,
raddr: raddr, raddr: raddr,
} }
@ -45,7 +45,7 @@ func (s *UoTTun) ListenAndServe() {
continue continue
} }
rc, err := s.sDialer.Dial("uot", s.raddr) rc, err := s.dialer.Dial("uot", s.raddr)
if err != nil { if err != nil {
logf("proxy-uottun failed to connect to server %v: %v", s.raddr, err) logf("proxy-uottun failed to connect to server %v: %v", s.raddr, err)
continue continue