mirror of
https://github.com/nadoo/glider.git
synced 2026-11-19 07:09:42 +08:00
proxy: add a new interface proxy to distinguish client and server
This commit is contained in:
1 parent
6c8141e43b
commit
edcb21236a
27 files changed
+371
-398
No files matched your search
+6
-9
@@ -9,19 +9,16 @@ import (
|
||||
"github.com/nadoo/glider/common/log"
|
||||
)
|
||||
|
||||
// Dialer means to establish a connection and relay it.
|
||||
// Dialer is used to create connection.
|
||||
type Dialer interface {
|
||||
// Addr()
|
||||
// Addr is the dialer's addr
|
||||
Addr() string
|
||||
|
||||
// Dial connects to the given address via the proxy.
|
||||
Dial(network, addr string) (c net.Conn, proxy string, err error)
|
||||
// Dial connects to the given address
|
||||
Dial(network, addr string) (c net.Conn, err error)
|
||||
|
||||
// DialUDP connects to the given address via the proxy.
|
||||
// DialUDP connects to the given address
|
||||
DialUDP(network, addr string) (pc net.PacketConn, writeTo net.Addr, err error)
|
||||
|
||||
// Get the dialer by dstAddr
|
||||
NextDialer(dstAddr string) Dialer
|
||||
}
|
||||
|
||||
// DialerCreator is a function to create dialers.
|
||||
@@ -31,7 +28,7 @@ var (
|
||||
dialerMap = make(map[string]DialerCreator)
|
||||
)
|
||||
|
||||
// RegisterDialer is used to register a dialer
|
||||
// RegisterDialer is used to register a dialer.
|
||||
func RegisterDialer(name string, c DialerCreator) {
|
||||
dialerMap[name] = c
|
||||
}
|
||||
|
||||
+2
-5
@@ -39,7 +39,7 @@ func NewDirect(intface string) (*Direct, error) {
|
||||
func (d *Direct) Addr() string { return "DIRECT" }
|
||||
|
||||
// Dial connects to the address addr on the network net
|
||||
func (d *Direct) Dial(network, addr string) (c net.Conn, p string, err error) {
|
||||
func (d *Direct) Dial(network, addr string) (c net.Conn, err error) {
|
||||
if d.iface == nil || d.ip != nil {
|
||||
c, err = dial(network, addr, d.ip)
|
||||
if err == nil {
|
||||
@@ -60,7 +60,7 @@ func (d *Direct) Dial(network, addr string) (c net.Conn, p string, err error) {
|
||||
err = errors.New("dial failed, maybe the interface link is down, please check it")
|
||||
}
|
||||
|
||||
return c, "DIRECT", err
|
||||
return c, err
|
||||
}
|
||||
|
||||
func dial(network, addr string, localIP net.IP) (net.Conn, error) {
|
||||
@@ -107,9 +107,6 @@ func (d *Direct) DialUDP(network, addr string) (net.PacketConn, net.Addr, error)
|
||||
return pc, uAddr, err
|
||||
}
|
||||
|
||||
// NextDialer returns the next dialer
|
||||
func (d *Direct) NextDialer(dstAddr string) Dialer { return d }
|
||||
|
||||
// IFaceIPs returns ip addresses according to the specified interface
|
||||
func (d *Direct) IFaceIPs() (ips []net.IP) {
|
||||
ipnets, err := d.iface.Addrs()
|
||||
|
||||
+16
-17
@@ -24,6 +24,7 @@ import (
|
||||
// HTTP struct
|
||||
type HTTP struct {
|
||||
dialer proxy.Dialer
|
||||
proxy proxy.Proxy
|
||||
addr string
|
||||
user string
|
||||
password string
|
||||
@@ -36,7 +37,7 @@ func init() {
|
||||
}
|
||||
|
||||
// NewHTTP returns a http proxy
|
||||
func NewHTTP(s string, dialer proxy.Dialer) (*HTTP, error) {
|
||||
func NewHTTP(s string, d proxy.Dialer, p proxy.Proxy) (*HTTP, error) {
|
||||
u, err := url.Parse(s)
|
||||
if err != nil {
|
||||
log.F("parse err: %s", err)
|
||||
@@ -48,7 +49,8 @@ func NewHTTP(s string, dialer proxy.Dialer) (*HTTP, error) {
|
||||
pass, _ := u.User.Password()
|
||||
|
||||
h := &HTTP{
|
||||
dialer: dialer,
|
||||
dialer: d,
|
||||
proxy: p,
|
||||
addr: addr,
|
||||
user: user,
|
||||
password: pass,
|
||||
@@ -64,13 +66,13 @@ func NewHTTP(s string, dialer proxy.Dialer) (*HTTP, error) {
|
||||
}
|
||||
|
||||
// NewHTTPDialer returns a http proxy dialer
|
||||
func NewHTTPDialer(s string, dialer proxy.Dialer) (proxy.Dialer, error) {
|
||||
return NewHTTP(s, dialer)
|
||||
func NewHTTPDialer(s string, d proxy.Dialer) (proxy.Dialer, error) {
|
||||
return NewHTTP(s, d, nil)
|
||||
}
|
||||
|
||||
// NewHTTPServer returns a http proxy server
|
||||
func NewHTTPServer(s string, dialer proxy.Dialer) (proxy.Server, error) {
|
||||
return NewHTTP(s, dialer)
|
||||
func NewHTTPServer(s string, p proxy.Proxy) (proxy.Server, error) {
|
||||
return NewHTTP(s, nil, p)
|
||||
}
|
||||
|
||||
// ListenAndServe .
|
||||
@@ -142,7 +144,7 @@ func (s *HTTP) Serve(c net.Conn) {
|
||||
tgt += ":80"
|
||||
}
|
||||
|
||||
rc, p, err := s.dialer.Dial("tcp", tgt)
|
||||
rc, p, err := s.proxy.Dial("tcp", tgt)
|
||||
if err != nil {
|
||||
fmt.Fprintf(c, "%s 502 ERROR\r\n\r\n", proto)
|
||||
log.F("[http] %s <-> %s, %s, error in dial: %v", c.RemoteAddr(), tgt, err, p)
|
||||
@@ -200,7 +202,7 @@ func (s *HTTP) Serve(c net.Conn) {
|
||||
}
|
||||
|
||||
func (s *HTTP) servHTTPS(method, requestURI, proto string, c net.Conn) {
|
||||
rc, p, err := s.dialer.Dial("tcp", requestURI)
|
||||
rc, p, err := s.proxy.Dial("tcp", requestURI)
|
||||
if err != nil {
|
||||
c.Write([]byte(proto))
|
||||
c.Write([]byte(" 502 ERROR\r\n\r\n"))
|
||||
@@ -229,15 +231,12 @@ func (s *HTTP) Addr() string {
|
||||
return s.addr
|
||||
}
|
||||
|
||||
// NextDialer returns the next dialer
|
||||
func (s *HTTP) NextDialer(dstAddr string) proxy.Dialer { return s.dialer.NextDialer(dstAddr) }
|
||||
|
||||
// Dial connects to the address addr on the network net via the proxy
|
||||
func (s *HTTP) Dial(network, addr string) (net.Conn, string, error) {
|
||||
rc, p, err := s.dialer.Dial(network, s.addr)
|
||||
func (s *HTTP) Dial(network, addr string) (net.Conn, error) {
|
||||
rc, err := s.dialer.Dial(network, s.addr)
|
||||
if err != nil {
|
||||
log.F("[http] dial to %s error: %s", s.addr, err)
|
||||
return nil, p, err
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var buf bytes.Buffer
|
||||
@@ -254,7 +253,7 @@ func (s *HTTP) Dial(network, addr string) (net.Conn, string, error) {
|
||||
buf.Write([]byte("\r\n"))
|
||||
_, err = rc.Write(buf.Bytes())
|
||||
if err != nil {
|
||||
return nil, p, err
|
||||
return nil, err
|
||||
}
|
||||
|
||||
c := conn.NewConn(rc)
|
||||
@@ -262,7 +261,7 @@ func (s *HTTP) Dial(network, addr string) (net.Conn, string, error) {
|
||||
_, code, _, ok := parseFirstLine(tpr)
|
||||
if ok && code == "200" {
|
||||
tpr.ReadMIMEHeader()
|
||||
return c, p, err
|
||||
return c, err
|
||||
}
|
||||
|
||||
if code == "407" {
|
||||
@@ -271,7 +270,7 @@ func (s *HTTP) Dial(network, addr string) (net.Conn, string, error) {
|
||||
log.F("[http] 'CONNECT' method not allowed by proxy %s", s.addr)
|
||||
}
|
||||
|
||||
return nil, p, errors.New("[http] can not connect remote address: " + addr + ". error code: " + code)
|
||||
return nil, errors.New("[http] can not connect remote address: " + addr + ". error code: " + code)
|
||||
}
|
||||
|
||||
// DialUDP connects to the given address via the proxy
|
||||
|
||||
+21
-22
@@ -18,6 +18,7 @@ import (
|
||||
// KCP struct
|
||||
type KCP struct {
|
||||
dialer proxy.Dialer
|
||||
proxy proxy.Proxy
|
||||
addr string
|
||||
|
||||
key string
|
||||
@@ -36,7 +37,7 @@ func init() {
|
||||
}
|
||||
|
||||
// NewKCP returns a kcp proxy struct
|
||||
func NewKCP(s string, dialer proxy.Dialer) (*KCP, error) {
|
||||
func NewKCP(s string, d proxy.Dialer, p proxy.Proxy) (*KCP, error) {
|
||||
u, err := url.Parse(s)
|
||||
if err != nil {
|
||||
log.F("[kcp] parse url err: %s", err)
|
||||
@@ -73,8 +74,9 @@ func NewKCP(s string, dialer proxy.Dialer) (*KCP, error) {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
p := &KCP{
|
||||
dialer: dialer,
|
||||
k := &KCP{
|
||||
dialer: d,
|
||||
proxy: p,
|
||||
addr: addr,
|
||||
key: key,
|
||||
crypt: crypt,
|
||||
@@ -82,10 +84,10 @@ func NewKCP(s string, dialer proxy.Dialer) (*KCP, error) {
|
||||
parityShards: int(parityShards),
|
||||
}
|
||||
|
||||
if p.crypt != "" {
|
||||
pass := pbkdf2.Key([]byte(p.key), []byte("kcp-go"), 4096, 32, sha1.New)
|
||||
if k.crypt != "" {
|
||||
pass := pbkdf2.Key([]byte(k.key), []byte("kcp-go"), 4096, 32, sha1.New)
|
||||
var block kcp.BlockCrypt
|
||||
switch p.crypt {
|
||||
switch k.crypt {
|
||||
case "sm4":
|
||||
block, _ = kcp.NewSM4BlockCrypt(pass[:16])
|
||||
case "tea":
|
||||
@@ -113,22 +115,22 @@ func NewKCP(s string, dialer proxy.Dialer) (*KCP, error) {
|
||||
case "salsa20":
|
||||
block, _ = kcp.NewSalsa20BlockCrypt(pass)
|
||||
default:
|
||||
return nil, errors.New("[kcp] unknown crypt type '" + p.crypt + "'")
|
||||
return nil, errors.New("[kcp] unknown crypt type '" + k.crypt + "'")
|
||||
}
|
||||
|
||||
p.block = block
|
||||
k.block = block
|
||||
}
|
||||
|
||||
return p, nil
|
||||
return k, nil
|
||||
}
|
||||
|
||||
// NewKCPDialer returns a kcp proxy dialer
|
||||
func NewKCPDialer(s string, dialer proxy.Dialer) (proxy.Dialer, error) {
|
||||
return NewKCP(s, dialer)
|
||||
func NewKCPDialer(s string, d proxy.Dialer) (proxy.Dialer, error) {
|
||||
return NewKCP(s, d, nil)
|
||||
}
|
||||
|
||||
// NewKCPServer returns a kcp proxy server
|
||||
func NewKCPServer(s string, dialer proxy.Dialer) (proxy.Server, error) {
|
||||
func NewKCPServer(s string, p proxy.Proxy) (proxy.Server, error) {
|
||||
transport := strings.Split(s, ",")
|
||||
|
||||
// prepare transport listener
|
||||
@@ -137,17 +139,17 @@ func NewKCPServer(s string, dialer proxy.Dialer) (proxy.Server, error) {
|
||||
return nil, errors.New("[kcp] malformd listener:" + s)
|
||||
}
|
||||
|
||||
p, err := NewKCP(transport[0], dialer)
|
||||
k, err := NewKCP(transport[0], nil, p)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
p.server, err = proxy.ServerFromURL(transport[1], dialer)
|
||||
k.server, err = proxy.ServerFromURL(transport[1], p)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return p, nil
|
||||
return k, nil
|
||||
}
|
||||
|
||||
// ListenAndServe .
|
||||
@@ -193,16 +195,13 @@ func (s *KCP) Serve(c net.Conn) {
|
||||
// Addr returns forwarder's address
|
||||
func (s *KCP) Addr() string { return s.addr }
|
||||
|
||||
// NextDialer returns the next dialer
|
||||
func (s *KCP) NextDialer(dstAddr string) proxy.Dialer { return s.dialer.NextDialer(dstAddr) }
|
||||
|
||||
// Dial connects to the address addr on the network net via the proxy
|
||||
func (s *KCP) Dial(network, addr string) (net.Conn, string, error) {
|
||||
func (s *KCP) Dial(network, addr string) (net.Conn, error) {
|
||||
// NOTE: kcp uses udp, we should dial remote server directly here
|
||||
c, err := kcp.DialWithOptions(s.addr, s.block, s.dataShards, s.parityShards)
|
||||
if err != nil {
|
||||
log.F("[tls] dial to %s error: %s", s.addr, err)
|
||||
return nil, "", err
|
||||
log.F("[kcp] dial to %s error: %s", s.addr, err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// TODO: change them to customizable later?
|
||||
@@ -217,7 +216,7 @@ func (s *KCP) Dial(network, addr string) (net.Conn, string, error) {
|
||||
c.SetReadBuffer(4194304)
|
||||
c.SetWriteBuffer(4194304)
|
||||
|
||||
return c, "", err
|
||||
return c, err
|
||||
}
|
||||
|
||||
// DialUDP connects to the given address via the proxy
|
||||
|
||||
+12
-12
@@ -27,11 +27,11 @@ var httpMethods = [...][]byte{
|
||||
|
||||
// MixedProxy struct
|
||||
type MixedProxy struct {
|
||||
dialer proxy.Dialer
|
||||
addr string
|
||||
proxy proxy.Proxy
|
||||
addr string
|
||||
|
||||
http *http.HTTP
|
||||
socks5 *socks5.SOCKS5
|
||||
socks5 *socks5.Socks5
|
||||
}
|
||||
|
||||
func init() {
|
||||
@@ -39,27 +39,27 @@ func init() {
|
||||
}
|
||||
|
||||
// NewMixedProxy returns a mixed proxy
|
||||
func NewMixedProxy(s string, dialer proxy.Dialer) (*MixedProxy, error) {
|
||||
func NewMixedProxy(s string, p proxy.Proxy) (*MixedProxy, error) {
|
||||
u, err := url.Parse(s)
|
||||
if err != nil {
|
||||
log.F("parse err: %s", err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
p := &MixedProxy{
|
||||
dialer: dialer,
|
||||
addr: u.Host,
|
||||
m := &MixedProxy{
|
||||
proxy: p,
|
||||
addr: u.Host,
|
||||
}
|
||||
|
||||
p.http, _ = http.NewHTTP(s, dialer)
|
||||
p.socks5, _ = socks5.NewSOCKS5(s, dialer)
|
||||
m.http, _ = http.NewHTTP(s, nil, p)
|
||||
m.socks5, _ = socks5.NewSocks5(s, nil, p)
|
||||
|
||||
return p, nil
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// NewMixedProxyServer returns a mixed proxy server
|
||||
func NewMixedProxyServer(s string, dialer proxy.Dialer) (proxy.Server, error) {
|
||||
return NewMixedProxy(s, dialer)
|
||||
func NewMixedProxyServer(s string, p proxy.Proxy) (proxy.Server, error) {
|
||||
return NewMixedProxy(s, p)
|
||||
}
|
||||
|
||||
// ListenAndServe .
|
||||
|
||||
+6
-9
@@ -28,7 +28,7 @@ func init() {
|
||||
}
|
||||
|
||||
// NewObfs returns a proxy struct
|
||||
func NewObfs(s string, dialer proxy.Dialer) (*Obfs, error) {
|
||||
func NewObfs(s string, d proxy.Dialer) (*Obfs, error) {
|
||||
u, err := url.Parse(s)
|
||||
if err != nil {
|
||||
log.F("parse url err: %s", err)
|
||||
@@ -59,7 +59,7 @@ func NewObfs(s string, dialer proxy.Dialer) (*Obfs, error) {
|
||||
}
|
||||
|
||||
p := &Obfs{
|
||||
dialer: dialer,
|
||||
dialer: d,
|
||||
addr: addr,
|
||||
obfsType: obfsType,
|
||||
obfsHost: obfsHost,
|
||||
@@ -89,19 +89,16 @@ func NewObfsDialer(s string, dialer proxy.Dialer) (proxy.Dialer, error) {
|
||||
// Addr returns forwarder's address
|
||||
func (s *Obfs) Addr() string { return s.addr }
|
||||
|
||||
// NextDialer returns the next dialer
|
||||
func (s *Obfs) NextDialer(dstAddr string) proxy.Dialer { return s.dialer.NextDialer(dstAddr) }
|
||||
|
||||
// Dial connects to the address addr on the network net via the proxy
|
||||
func (s *Obfs) Dial(network, addr string) (net.Conn, string, error) {
|
||||
c, p, err := s.dialer.Dial("tcp", s.addr)
|
||||
func (s *Obfs) Dial(network, addr string) (net.Conn, error) {
|
||||
c, err := s.dialer.Dial("tcp", s.addr)
|
||||
if err != nil {
|
||||
log.F("[obfs] dial to %s error: %s", s.addr, err)
|
||||
return nil, p, err
|
||||
return nil, err
|
||||
}
|
||||
|
||||
cc, e := s.obfsConn(c)
|
||||
return cc, p, e
|
||||
return cc, e
|
||||
}
|
||||
|
||||
// DialUDP connects to the given address via the proxy
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
package proxy
|
||||
|
||||
import "net"
|
||||
|
||||
// Proxy is a dialer manager
|
||||
type Proxy interface {
|
||||
// Dial connects to the given address via the proxy.
|
||||
Dial(network, addr string) (c net.Conn, proxy string, err error)
|
||||
|
||||
// DialUDP connects to the given address via the proxy.
|
||||
DialUDP(network, addr string) (pc net.PacketConn, writeTo net.Addr, err error)
|
||||
|
||||
// Get the dialer by dstAddr
|
||||
NextDialer(dstAddr string) Dialer
|
||||
}
|
||||
+12
-12
@@ -25,9 +25,9 @@ const (
|
||||
|
||||
// RedirProxy struct
|
||||
type RedirProxy struct {
|
||||
dialer proxy.Dialer
|
||||
addr string
|
||||
ipv6 bool
|
||||
proxy proxy.Proxy
|
||||
addr string
|
||||
ipv6 bool
|
||||
}
|
||||
|
||||
func init() {
|
||||
@@ -36,7 +36,7 @@ func init() {
|
||||
}
|
||||
|
||||
// NewRedirProxy returns a redirect proxy.
|
||||
func NewRedirProxy(s string, dialer proxy.Dialer, ipv6 bool) (*RedirProxy, error) {
|
||||
func NewRedirProxy(s string, p proxy.Proxy, ipv6 bool) (*RedirProxy, error) {
|
||||
u, err := url.Parse(s)
|
||||
if err != nil {
|
||||
log.F("parse err: %s", err)
|
||||
@@ -45,22 +45,22 @@ func NewRedirProxy(s string, dialer proxy.Dialer, ipv6 bool) (*RedirProxy, error
|
||||
|
||||
addr := u.Host
|
||||
r := &RedirProxy{
|
||||
dialer: dialer,
|
||||
addr: addr,
|
||||
ipv6: ipv6,
|
||||
proxy: p,
|
||||
addr: addr,
|
||||
ipv6: ipv6,
|
||||
}
|
||||
|
||||
return r, nil
|
||||
}
|
||||
|
||||
// NewRedirServer returns a redir server.
|
||||
func NewRedirServer(s string, dialer proxy.Dialer) (proxy.Server, error) {
|
||||
return NewRedirProxy(s, dialer, false)
|
||||
func NewRedirServer(s string, p proxy.Proxy) (proxy.Server, error) {
|
||||
return NewRedirProxy(s, p, false)
|
||||
}
|
||||
|
||||
// NewRedir6Server returns a redir server for ipv6.
|
||||
func NewRedir6Server(s string, dialer proxy.Dialer) (proxy.Server, error) {
|
||||
return NewRedirProxy(s, dialer, true)
|
||||
func NewRedir6Server(s string, p proxy.Proxy) (proxy.Server, error) {
|
||||
return NewRedirProxy(s, p, true)
|
||||
}
|
||||
|
||||
// ListenAndServe .
|
||||
@@ -104,7 +104,7 @@ func (s *RedirProxy) Serve(c net.Conn) {
|
||||
return
|
||||
}
|
||||
|
||||
rc, p, err := s.dialer.Dial("tcp", tgt.String())
|
||||
rc, p, err := s.proxy.Dial("tcp", tgt.String())
|
||||
if err != nil {
|
||||
log.F("[redir] %s <-> %s, %s, error in dial: %v", c.RemoteAddr(), tgt, err, p)
|
||||
return
|
||||
|
||||
@@ -16,24 +16,21 @@ func init() {
|
||||
}
|
||||
|
||||
// NewReject returns a reject proxy, reject://
|
||||
func NewReject(s string, dialer proxy.Dialer) (*Reject, error) {
|
||||
func NewReject(s string, d proxy.Dialer) (*Reject, error) {
|
||||
return &Reject{}, nil
|
||||
}
|
||||
|
||||
// NewRejectDialer returns a reject proxy dialer.
|
||||
func NewRejectDialer(s string, dialer proxy.Dialer) (proxy.Dialer, error) {
|
||||
return NewReject(s, dialer)
|
||||
func NewRejectDialer(s string, d proxy.Dialer) (proxy.Dialer, error) {
|
||||
return NewReject(s, d)
|
||||
}
|
||||
|
||||
// Addr returns forwarder's address.
|
||||
func (s *Reject) Addr() string { return "REJECT" }
|
||||
|
||||
// NextDialer returns the next dialer.
|
||||
func (s *Reject) NextDialer(dstAddr string) proxy.Dialer { return s }
|
||||
|
||||
// Dial connects to the address addr on the network net via the proxy.
|
||||
func (s *Reject) Dial(network, addr string) (net.Conn, string, error) {
|
||||
return nil, "REJECT", errors.New("REJECT")
|
||||
func (s *Reject) Dial(network, addr string) (net.Conn, error) {
|
||||
return nil, errors.New("REJECT")
|
||||
}
|
||||
|
||||
// DialUDP connects to the given address via the proxy.
|
||||
|
||||
+4
-4
@@ -19,7 +19,7 @@ type Server interface {
|
||||
}
|
||||
|
||||
// ServerCreator is a function to create proxy servers
|
||||
type ServerCreator func(s string, dialer Dialer) (Server, error)
|
||||
type ServerCreator func(s string, proxy Proxy) (Server, error)
|
||||
|
||||
var (
|
||||
serverMap = make(map[string]ServerCreator)
|
||||
@@ -32,8 +32,8 @@ func RegisterServer(name string, c ServerCreator) {
|
||||
|
||||
// ServerFromURL calls the registered creator to create proxy servers
|
||||
// dialer is the default upstream dialer so cannot be nil, we can use Default when calling this function
|
||||
func ServerFromURL(s string, dialer Dialer) (Server, error) {
|
||||
if dialer == nil {
|
||||
func ServerFromURL(s string, p Proxy) (Server, error) {
|
||||
if p == nil {
|
||||
return nil, errors.New("ServerFromURL: dialer cannot be nil")
|
||||
}
|
||||
|
||||
@@ -49,7 +49,7 @@ func ServerFromURL(s string, dialer Dialer) (Server, error) {
|
||||
|
||||
c, ok := serverMap[strings.ToLower(u.Scheme)]
|
||||
if ok {
|
||||
return c(s, dialer)
|
||||
return c(s, p)
|
||||
}
|
||||
|
||||
return nil, errors.New("unknown scheme '" + u.Scheme + "'")
|
||||
|
||||
+28
-29
@@ -30,9 +30,10 @@ import (
|
||||
// Version is socks5 version number.
|
||||
const Version = 5
|
||||
|
||||
// SOCKS5 is a base socks5 struct.
|
||||
type SOCKS5 struct {
|
||||
// Socks5 is a base socks5 struct.
|
||||
type Socks5 struct {
|
||||
dialer proxy.Dialer
|
||||
proxy proxy.Proxy
|
||||
addr string
|
||||
user string
|
||||
password string
|
||||
@@ -43,9 +44,9 @@ func init() {
|
||||
proxy.RegisterServer("socks5", NewSocks5Server)
|
||||
}
|
||||
|
||||
// NewSOCKS5 returns a Proxy that makes SOCKS v5 connections to the given address
|
||||
// NewSocks5 returns a Proxy that makes SOCKS v5 connections to the given address
|
||||
// with an optional username and password. (RFC 1928)
|
||||
func NewSOCKS5(s string, dialer proxy.Dialer) (*SOCKS5, error) {
|
||||
func NewSocks5(s string, d proxy.Dialer, p proxy.Proxy) (*Socks5, error) {
|
||||
u, err := url.Parse(s)
|
||||
if err != nil {
|
||||
log.F("parse err: %s", err)
|
||||
@@ -56,8 +57,9 @@ func NewSOCKS5(s string, dialer proxy.Dialer) (*SOCKS5, error) {
|
||||
user := u.User.Username()
|
||||
pass, _ := u.User.Password()
|
||||
|
||||
h := &SOCKS5{
|
||||
dialer: dialer,
|
||||
h := &Socks5{
|
||||
dialer: d,
|
||||
proxy: p,
|
||||
addr: addr,
|
||||
user: user,
|
||||
password: pass,
|
||||
@@ -67,23 +69,23 @@ func NewSOCKS5(s string, dialer proxy.Dialer) (*SOCKS5, error) {
|
||||
}
|
||||
|
||||
// NewSocks5Dialer returns a socks5 proxy dialer.
|
||||
func NewSocks5Dialer(s string, dialer proxy.Dialer) (proxy.Dialer, error) {
|
||||
return NewSOCKS5(s, dialer)
|
||||
func NewSocks5Dialer(s string, d proxy.Dialer) (proxy.Dialer, error) {
|
||||
return NewSocks5(s, d, nil)
|
||||
}
|
||||
|
||||
// NewSocks5Server returns a socks5 proxy server.
|
||||
func NewSocks5Server(s string, dialer proxy.Dialer) (proxy.Server, error) {
|
||||
return NewSOCKS5(s, dialer)
|
||||
func NewSocks5Server(s string, p proxy.Proxy) (proxy.Server, error) {
|
||||
return NewSocks5(s, nil, p)
|
||||
}
|
||||
|
||||
// ListenAndServe serves socks5 requests.
|
||||
func (s *SOCKS5) ListenAndServe() {
|
||||
func (s *Socks5) ListenAndServe() {
|
||||
go s.ListenAndServeUDP()
|
||||
s.ListenAndServeTCP()
|
||||
}
|
||||
|
||||
// ListenAndServeTCP listen and serve on tcp port.
|
||||
func (s *SOCKS5) ListenAndServeTCP() {
|
||||
func (s *Socks5) ListenAndServeTCP() {
|
||||
l, err := net.Listen("tcp", s.addr)
|
||||
if err != nil {
|
||||
log.F("[socks5] failed to listen on %s: %v", s.addr, err)
|
||||
@@ -104,7 +106,7 @@ func (s *SOCKS5) ListenAndServeTCP() {
|
||||
}
|
||||
|
||||
// Serve serves a connection.
|
||||
func (s *SOCKS5) Serve(c net.Conn) {
|
||||
func (s *Socks5) Serve(c net.Conn) {
|
||||
defer c.Close()
|
||||
|
||||
if c, ok := c.(*net.TCPConn); ok {
|
||||
@@ -131,7 +133,7 @@ func (s *SOCKS5) Serve(c net.Conn) {
|
||||
return
|
||||
}
|
||||
|
||||
rc, p, err := s.dialer.Dial("tcp", tgt.String())
|
||||
rc, p, err := s.proxy.Dial("tcp", tgt.String())
|
||||
if err != nil {
|
||||
log.F("[socks5] %s <-> %s, %s, error in dial: %v", c.RemoteAddr(), tgt, err, p)
|
||||
return
|
||||
@@ -150,7 +152,7 @@ func (s *SOCKS5) Serve(c net.Conn) {
|
||||
}
|
||||
|
||||
// ListenAndServeUDP serves udp requests.
|
||||
func (s *SOCKS5) ListenAndServeUDP() {
|
||||
func (s *Socks5) ListenAndServeUDP() {
|
||||
lc, err := net.ListenPacket("udp", s.addr)
|
||||
if err != nil {
|
||||
log.F("[socks5-udp] failed to listen on %s: %v", s.addr, err)
|
||||
@@ -213,41 +215,38 @@ func (s *SOCKS5) ListenAndServeUDP() {
|
||||
}
|
||||
|
||||
// Addr returns forwarder's address.
|
||||
func (s *SOCKS5) Addr() string {
|
||||
func (s *Socks5) Addr() string {
|
||||
if s.addr == "" {
|
||||
return s.dialer.Addr()
|
||||
}
|
||||
return s.addr
|
||||
}
|
||||
|
||||
// NextDialer returns the next dialer.
|
||||
func (s *SOCKS5) NextDialer(dstAddr string) proxy.Dialer { return s.dialer.NextDialer(dstAddr) }
|
||||
|
||||
// Dial connects to the address addr on the network net via the SOCKS5 proxy.
|
||||
func (s *SOCKS5) Dial(network, addr string) (net.Conn, string, error) {
|
||||
func (s *Socks5) Dial(network, addr string) (net.Conn, error) {
|
||||
switch network {
|
||||
case "tcp", "tcp6", "tcp4":
|
||||
default:
|
||||
return nil, "", errors.New("[socks5]: no support for connection type " + network)
|
||||
return nil, errors.New("[socks5]: no support for connection type " + network)
|
||||
}
|
||||
|
||||
c, p, err := s.dialer.Dial(network, s.addr)
|
||||
c, err := s.dialer.Dial(network, s.addr)
|
||||
if err != nil {
|
||||
log.F("[socks5]: dial to %s error: %s", s.addr, err)
|
||||
return nil, p, err
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if err := s.connect(c, addr); err != nil {
|
||||
c.Close()
|
||||
return nil, p, err
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return c, p, nil
|
||||
return c, nil
|
||||
}
|
||||
|
||||
// DialUDP connects to the given address via the proxy.
|
||||
func (s *SOCKS5) DialUDP(network, addr string) (pc net.PacketConn, writeTo net.Addr, err error) {
|
||||
c, _, err := s.dialer.Dial("tcp", s.addr)
|
||||
func (s *Socks5) DialUDP(network, addr string) (pc net.PacketConn, writeTo net.Addr, err error) {
|
||||
c, err := s.dialer.Dial("tcp", s.addr)
|
||||
if err != nil {
|
||||
log.F("[socks5] dialudp dial tcp to %s error: %s", s.addr, err)
|
||||
return nil, nil, err
|
||||
@@ -295,7 +294,7 @@ func (s *SOCKS5) DialUDP(network, addr string) (pc net.PacketConn, writeTo net.A
|
||||
// connect takes an existing connection to a socks5 proxy server,
|
||||
// and commands the server to extend that connection to target,
|
||||
// which must be a canonical address with a host and port.
|
||||
func (s *SOCKS5) connect(conn net.Conn, target string) error {
|
||||
func (s *Socks5) connect(conn net.Conn, target string) error {
|
||||
host, portStr, err := net.SplitHostPort(target)
|
||||
if err != nil {
|
||||
return err
|
||||
@@ -426,7 +425,7 @@ func (s *SOCKS5) connect(conn net.Conn, target string) error {
|
||||
}
|
||||
|
||||
// Handshake fast-tracks SOCKS initialization to get target address to connect.
|
||||
func (s *SOCKS5) handshake(rw io.ReadWriter) (socks.Addr, error) {
|
||||
func (s *Socks5) handshake(rw io.ReadWriter) (socks.Addr, error) {
|
||||
// Read RFC 1928 for request and reply structure and sizes
|
||||
buf := make([]byte, socks.MaxAddrLen)
|
||||
// read VER, NMETHODS, METHODS
|
||||
|
||||
+20
-21
@@ -19,6 +19,7 @@ import (
|
||||
// SS is a base ss struct.
|
||||
type SS struct {
|
||||
dialer proxy.Dialer
|
||||
proxy proxy.Proxy
|
||||
addr string
|
||||
|
||||
core.Cipher
|
||||
@@ -30,7 +31,7 @@ func init() {
|
||||
}
|
||||
|
||||
// NewSS returns a ss proxy.
|
||||
func NewSS(s string, dialer proxy.Dialer) (*SS, error) {
|
||||
func NewSS(s string, d proxy.Dialer, p proxy.Proxy) (*SS, error) {
|
||||
u, err := url.Parse(s)
|
||||
if err != nil {
|
||||
log.F("parse err: %s", err)
|
||||
@@ -46,23 +47,24 @@ func NewSS(s string, dialer proxy.Dialer) (*SS, error) {
|
||||
log.Fatalf("[ss] PickCipher for '%s', error: %s", method, err)
|
||||
}
|
||||
|
||||
p := &SS{
|
||||
dialer: dialer,
|
||||
ss := &SS{
|
||||
dialer: d,
|
||||
proxy: p,
|
||||
addr: addr,
|
||||
Cipher: ciph,
|
||||
}
|
||||
|
||||
return p, nil
|
||||
return ss, nil
|
||||
}
|
||||
|
||||
// NewSSDialer returns a ss proxy dialer.
|
||||
func NewSSDialer(s string, dialer proxy.Dialer) (proxy.Dialer, error) {
|
||||
return NewSS(s, dialer)
|
||||
func NewSSDialer(s string, d proxy.Dialer) (proxy.Dialer, error) {
|
||||
return NewSS(s, d, nil)
|
||||
}
|
||||
|
||||
// NewSSServer returns a ss proxy server.
|
||||
func NewSSServer(s string, dialer proxy.Dialer) (proxy.Server, error) {
|
||||
return NewSS(s, dialer)
|
||||
func NewSSServer(s string, p proxy.Proxy) (proxy.Server, error) {
|
||||
return NewSS(s, nil, p)
|
||||
}
|
||||
|
||||
// ListenAndServe serves ss requests.
|
||||
@@ -108,7 +110,7 @@ func (s *SS) Serve(c net.Conn) {
|
||||
return
|
||||
}
|
||||
|
||||
dialer := s.dialer.NextDialer(tgt.String())
|
||||
dialer := s.proxy.NextDialer(tgt.String())
|
||||
|
||||
// udp over tcp?
|
||||
uot := socks.UoT(tgt[0])
|
||||
@@ -147,14 +149,14 @@ func (s *SS) Serve(c net.Conn) {
|
||||
network = "udp"
|
||||
}
|
||||
|
||||
rc, p, err := dialer.Dial(network, tgt.String())
|
||||
rc, err := dialer.Dial(network, tgt.String())
|
||||
if err != nil {
|
||||
log.F("[ss] %s <-> %s, %s, error in dial: %v", c.RemoteAddr(), tgt, err, p)
|
||||
log.F("[ss] %s <-> %s, %s, error in dial: %v", c.RemoteAddr(), tgt, err, dialer.Addr())
|
||||
return
|
||||
}
|
||||
defer rc.Close()
|
||||
|
||||
log.F("[ss] %s <-> %s, %s", c.RemoteAddr(), tgt, p)
|
||||
log.F("[ss] %s <-> %s, %s", c.RemoteAddr(), tgt, dialer.Addr())
|
||||
|
||||
_, _, err = conn.Relay(c, rc)
|
||||
if err != nil {
|
||||
@@ -238,33 +240,30 @@ func (s *SS) Addr() string {
|
||||
return s.addr
|
||||
}
|
||||
|
||||
// NextDialer returns the next dialer.
|
||||
func (s *SS) NextDialer(dstAddr string) proxy.Dialer { return s.dialer.NextDialer(dstAddr) }
|
||||
|
||||
// Dial connects to the address addr on the network net via the proxy.
|
||||
func (s *SS) Dial(network, addr string) (net.Conn, string, error) {
|
||||
func (s *SS) Dial(network, addr string) (net.Conn, error) {
|
||||
target := socks.ParseAddr(addr)
|
||||
if target == nil {
|
||||
return nil, "", errors.New("[ss] unable to parse address: " + addr)
|
||||
return nil, errors.New("[ss] unable to parse address: " + addr)
|
||||
}
|
||||
|
||||
if network == "uot" {
|
||||
target[0] = target[0] | 0x8
|
||||
}
|
||||
|
||||
c, p, err := s.dialer.Dial("tcp", s.addr)
|
||||
c, err := s.dialer.Dial("tcp", s.addr)
|
||||
if err != nil {
|
||||
log.F("[ss] dial to %s error: %s", s.addr, err)
|
||||
return nil, p, err
|
||||
return nil, err
|
||||
}
|
||||
|
||||
c = s.StreamConn(c)
|
||||
if _, err = c.Write(target); err != nil {
|
||||
c.Close()
|
||||
return nil, p, err
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return c, p, err
|
||||
return c, err
|
||||
|
||||
}
|
||||
|
||||
|
||||
+14
-17
@@ -37,7 +37,7 @@ func init() {
|
||||
}
|
||||
|
||||
// NewSSR returns a shadowsocksr proxy, ssr://method:pass@host:port/query
|
||||
func NewSSR(s string, dialer proxy.Dialer) (*SSR, error) {
|
||||
func NewSSR(s string, d proxy.Dialer) (*SSR, error) {
|
||||
u, err := url.Parse(s)
|
||||
if err != nil {
|
||||
log.F("parse err: %s", err)
|
||||
@@ -49,7 +49,7 @@ func NewSSR(s string, dialer proxy.Dialer) (*SSR, error) {
|
||||
pass, _ := u.User.Password()
|
||||
|
||||
p := &SSR{
|
||||
dialer: dialer,
|
||||
dialer: d,
|
||||
addr: addr,
|
||||
EncryptMethod: method,
|
||||
EncryptPassword: pass,
|
||||
@@ -65,8 +65,8 @@ func NewSSR(s string, dialer proxy.Dialer) (*SSR, error) {
|
||||
}
|
||||
|
||||
// NewSSRDialer returns a ssr proxy dialer.
|
||||
func NewSSRDialer(s string, dialer proxy.Dialer) (proxy.Dialer, error) {
|
||||
return NewSSR(s, dialer)
|
||||
func NewSSRDialer(s string, d proxy.Dialer) (proxy.Dialer, error) {
|
||||
return NewSSR(s, d)
|
||||
}
|
||||
|
||||
// Addr returns forwarder's address
|
||||
@@ -77,30 +77,27 @@ func (s *SSR) Addr() string {
|
||||
return s.addr
|
||||
}
|
||||
|
||||
// NextDialer returns the next dialer
|
||||
func (s *SSR) NextDialer(dstAddr string) proxy.Dialer { return s.dialer.NextDialer(dstAddr) }
|
||||
|
||||
// Dial connects to the address addr on the network net via the proxy.
|
||||
func (s *SSR) Dial(network, addr string) (net.Conn, string, error) {
|
||||
func (s *SSR) Dial(network, addr string) (net.Conn, error) {
|
||||
target := socks.ParseAddr(addr)
|
||||
if target == nil {
|
||||
return nil, "", errors.New("[ssr] unable to parse address: " + addr)
|
||||
return nil, errors.New("[ssr] unable to parse address: " + addr)
|
||||
}
|
||||
|
||||
cipher, err := shadowsocksr.NewStreamCipher(s.EncryptMethod, s.EncryptPassword)
|
||||
if err != nil {
|
||||
return nil, "", err
|
||||
return nil, err
|
||||
}
|
||||
|
||||
c, p, err := s.dialer.Dial("tcp", s.addr)
|
||||
c, err := s.dialer.Dial("tcp", s.addr)
|
||||
if err != nil {
|
||||
log.F("[ssr] dial to %s error: %s", s.addr, err)
|
||||
return nil, p, err
|
||||
return nil, err
|
||||
}
|
||||
|
||||
ssrconn := shadowsocksr.NewSSTCPConn(c, cipher)
|
||||
if ssrconn.Conn == nil || ssrconn.RemoteAddr() == nil {
|
||||
return nil, p, errors.New("[ssr] nil connection")
|
||||
return nil, errors.New("[ssr] nil connection")
|
||||
}
|
||||
|
||||
// should initialize obfs/protocol now
|
||||
@@ -109,7 +106,7 @@ func (s *SSR) Dial(network, addr string) (net.Conn, string, error) {
|
||||
|
||||
ssrconn.IObfs = obfs.NewObfs(s.Obfs)
|
||||
if ssrconn.IObfs == nil {
|
||||
return nil, p, errors.New("[ssr] unsupported obfs type: " + s.Obfs)
|
||||
return nil, errors.New("[ssr] unsupported obfs type: " + s.Obfs)
|
||||
}
|
||||
|
||||
obfsServerInfo := &ssr.ServerInfoForObfs{
|
||||
@@ -122,7 +119,7 @@ func (s *SSR) Dial(network, addr string) (net.Conn, string, error) {
|
||||
|
||||
ssrconn.IProtocol = protocol.NewProtocol(s.Protocol)
|
||||
if ssrconn.IProtocol == nil {
|
||||
return nil, p, errors.New("[ssr] unsupported protocol type: " + s.Protocol)
|
||||
return nil, errors.New("[ssr] unsupported protocol type: " + s.Protocol)
|
||||
}
|
||||
|
||||
protocolServerInfo := &ssr.ServerInfoForObfs{
|
||||
@@ -145,10 +142,10 @@ func (s *SSR) Dial(network, addr string) (net.Conn, string, error) {
|
||||
|
||||
if _, err := ssrconn.Write(target); err != nil {
|
||||
ssrconn.Close()
|
||||
return nil, p, err
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return ssrconn, p, err
|
||||
return ssrconn, err
|
||||
}
|
||||
|
||||
// DialUDP connects to the given address via the proxy.
|
||||
|
||||
+11
-11
@@ -12,8 +12,8 @@ import (
|
||||
|
||||
// TCPTun struct
|
||||
type TCPTun struct {
|
||||
dialer proxy.Dialer
|
||||
addr string
|
||||
proxy proxy.Proxy
|
||||
addr string
|
||||
|
||||
raddr string
|
||||
}
|
||||
@@ -23,7 +23,7 @@ func init() {
|
||||
}
|
||||
|
||||
// NewTCPTun returns a tcptun proxy
|
||||
func NewTCPTun(s string, dialer proxy.Dialer) (*TCPTun, error) {
|
||||
func NewTCPTun(s string, p proxy.Proxy) (*TCPTun, error) {
|
||||
u, err := url.Parse(s)
|
||||
if err != nil {
|
||||
log.F("parse err: %s", err)
|
||||
@@ -33,18 +33,18 @@ func NewTCPTun(s string, dialer proxy.Dialer) (*TCPTun, error) {
|
||||
addr := u.Host
|
||||
d := strings.Split(addr, "=")
|
||||
|
||||
p := &TCPTun{
|
||||
dialer: dialer,
|
||||
addr: d[0],
|
||||
raddr: d[1],
|
||||
t := &TCPTun{
|
||||
proxy: p,
|
||||
addr: d[0],
|
||||
raddr: d[1],
|
||||
}
|
||||
|
||||
return p, nil
|
||||
return t, nil
|
||||
}
|
||||
|
||||
// NewTCPTunServer returns a udp tunnel server
|
||||
func NewTCPTunServer(s string, dialer proxy.Dialer) (proxy.Server, error) {
|
||||
return NewTCPTun(s, dialer)
|
||||
func NewTCPTunServer(s string, p proxy.Proxy) (proxy.Server, error) {
|
||||
return NewTCPTun(s, p)
|
||||
}
|
||||
|
||||
// ListenAndServe .
|
||||
@@ -76,7 +76,7 @@ func (s *TCPTun) Serve(c net.Conn) {
|
||||
c.SetKeepAlive(true)
|
||||
}
|
||||
|
||||
rc, p, err := s.dialer.Dial("tcp", s.raddr)
|
||||
rc, p, err := s.proxy.Dial("tcp", s.raddr)
|
||||
if err != nil {
|
||||
log.F("[tcptun] %s <-> %s, %s, error in dial: %v", c.RemoteAddr(), s.addr, err, p)
|
||||
return
|
||||
|
||||
+20
-22
@@ -14,6 +14,7 @@ import (
|
||||
// TLS struct
|
||||
type TLS struct {
|
||||
dialer proxy.Dialer
|
||||
proxy proxy.Proxy
|
||||
addr string
|
||||
|
||||
tlsConfig *stdtls.Config
|
||||
@@ -34,7 +35,7 @@ func init() {
|
||||
}
|
||||
|
||||
// NewTLS returns a tls proxy struct
|
||||
func NewTLS(s string, dialer proxy.Dialer) (*TLS, error) {
|
||||
func NewTLS(s string, d proxy.Dialer, p proxy.Proxy) (*TLS, error) {
|
||||
u, err := url.Parse(s)
|
||||
if err != nil {
|
||||
log.F("parse url err: %s", err)
|
||||
@@ -53,9 +54,9 @@ func NewTLS(s string, dialer proxy.Dialer) (*TLS, error) {
|
||||
certFile := query.Get("cert")
|
||||
keyFile := query.Get("key")
|
||||
|
||||
p := &TLS{
|
||||
dialer: dialer,
|
||||
addr: addr,
|
||||
t := &TLS{
|
||||
dialer: d,
|
||||
proxy: p,
|
||||
serverName: serverName,
|
||||
skipVerify: false,
|
||||
certFile: certFile,
|
||||
@@ -63,15 +64,15 @@ func NewTLS(s string, dialer proxy.Dialer) (*TLS, error) {
|
||||
}
|
||||
|
||||
if skipVerify == "true" {
|
||||
p.skipVerify = true
|
||||
t.skipVerify = true
|
||||
}
|
||||
|
||||
return p, nil
|
||||
return t, nil
|
||||
}
|
||||
|
||||
// NewTLSDialer returns a tls proxy dialer
|
||||
func NewTLSDialer(s string, dialer proxy.Dialer) (proxy.Dialer, error) {
|
||||
p, err := NewTLS(s, dialer)
|
||||
func NewTLSDialer(s string, d proxy.Dialer) (proxy.Dialer, error) {
|
||||
p, err := NewTLS(s, d, nil)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -87,7 +88,7 @@ func NewTLSDialer(s string, dialer proxy.Dialer) (proxy.Dialer, error) {
|
||||
}
|
||||
|
||||
// NewTLSServer returns a tls transport layer before the real server
|
||||
func NewTLSServer(s string, dialer proxy.Dialer) (proxy.Server, error) {
|
||||
func NewTLSServer(s string, p proxy.Proxy) (proxy.Server, error) {
|
||||
transport := strings.Split(s, ",")
|
||||
|
||||
// prepare transport listener
|
||||
@@ -96,28 +97,28 @@ func NewTLSServer(s string, dialer proxy.Dialer) (proxy.Server, error) {
|
||||
return nil, errors.New("[tls] malformd listener:" + s)
|
||||
}
|
||||
|
||||
p, err := NewTLS(transport[0], dialer)
|
||||
t, err := NewTLS(transport[0], nil, p)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
cert, err := stdtls.LoadX509KeyPair(p.certFile, p.keyFile)
|
||||
cert, err := stdtls.LoadX509KeyPair(t.certFile, t.keyFile)
|
||||
if err != nil {
|
||||
log.F("[tls] unable to load cert: %s, key %s", p.certFile, p.keyFile)
|
||||
log.F("[tls] unable to load cert: %s, key %s", t.certFile, t.keyFile)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
p.tlsConfig = &stdtls.Config{
|
||||
t.tlsConfig = &stdtls.Config{
|
||||
Certificates: []stdtls.Certificate{cert},
|
||||
MinVersion: stdtls.VersionTLS10,
|
||||
}
|
||||
|
||||
p.server, err = proxy.ServerFromURL(transport[1], dialer)
|
||||
t.server, err = proxy.ServerFromURL(transport[1], p)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return p, nil
|
||||
return t, nil
|
||||
}
|
||||
|
||||
// ListenAndServe .
|
||||
@@ -156,20 +157,17 @@ func (s *TLS) Serve(c net.Conn) {
|
||||
// Addr returns forwarder's address
|
||||
func (s *TLS) Addr() string { return s.addr }
|
||||
|
||||
// NextDialer returns the next dialer
|
||||
func (s *TLS) NextDialer(dstAddr string) proxy.Dialer { return s.dialer.NextDialer(dstAddr) }
|
||||
|
||||
// Dial connects to the address addr on the network net via the proxy
|
||||
func (s *TLS) Dial(network, addr string) (net.Conn, string, error) {
|
||||
cc, p, err := s.dialer.Dial("tcp", s.addr)
|
||||
func (s *TLS) Dial(network, addr string) (net.Conn, error) {
|
||||
cc, err := s.dialer.Dial("tcp", s.addr)
|
||||
if err != nil {
|
||||
log.F("[tls] dial to %s error: %s", s.addr, err)
|
||||
return nil, p, err
|
||||
return nil, err
|
||||
}
|
||||
|
||||
c := stdtls.Client(cc, s.tlsConfig)
|
||||
err = c.Handshake()
|
||||
return c, p, err
|
||||
return c, err
|
||||
}
|
||||
|
||||
// DialUDP connects to the given address via the proxy
|
||||
|
||||
@@ -19,8 +19,8 @@ import (
|
||||
|
||||
// TProxy struct
|
||||
type TProxy struct {
|
||||
dialer proxy.Dialer
|
||||
addr string
|
||||
proxy proxy.Proxy
|
||||
addr string
|
||||
}
|
||||
|
||||
func init() {
|
||||
@@ -28,7 +28,7 @@ func init() {
|
||||
}
|
||||
|
||||
// NewTProxy returns a tproxy.
|
||||
func NewTProxy(s string, dialer proxy.Dialer) (*TProxy, error) {
|
||||
func NewTProxy(s string, p proxy.Proxy) (*TProxy, error) {
|
||||
u, err := url.Parse(s)
|
||||
if err != nil {
|
||||
log.F("parse err: %s", err)
|
||||
@@ -37,17 +37,17 @@ func NewTProxy(s string, dialer proxy.Dialer) (*TProxy, error) {
|
||||
|
||||
addr := u.Host
|
||||
|
||||
p := &TProxy{
|
||||
dialer: dialer,
|
||||
addr: addr,
|
||||
tp := &TProxy{
|
||||
proxy: p,
|
||||
addr: addr,
|
||||
}
|
||||
|
||||
return p, nil
|
||||
return tp, nil
|
||||
}
|
||||
|
||||
// NewTProxyServer returns a udp tunnel server.
|
||||
func NewTProxyServer(s string, dialer proxy.Dialer) (proxy.Server, error) {
|
||||
return NewTProxy(s, dialer)
|
||||
func NewTProxyServer(s string, p proxy.Proxy) (proxy.Server, error) {
|
||||
return NewTProxy(s, p)
|
||||
}
|
||||
|
||||
// ListenAndServe .
|
||||
|
||||
+11
-11
@@ -14,7 +14,7 @@ import (
|
||||
|
||||
// UDPTun is a base udptun struct.
|
||||
type UDPTun struct {
|
||||
dialer proxy.Dialer
|
||||
proxy proxy.Proxy
|
||||
addr string
|
||||
taddr string // tunnel addr string
|
||||
tuaddr *net.UDPAddr // tunnel addr
|
||||
@@ -25,7 +25,7 @@ func init() {
|
||||
}
|
||||
|
||||
// NewUDPTun returns a UDPTun proxy.
|
||||
func NewUDPTun(s string, dialer proxy.Dialer) (*UDPTun, error) {
|
||||
func NewUDPTun(s string, p proxy.Proxy) (*UDPTun, error) {
|
||||
u, err := url.Parse(s)
|
||||
if err != nil {
|
||||
log.F("[udptun] parse err: %s", err)
|
||||
@@ -35,19 +35,19 @@ func NewUDPTun(s string, dialer proxy.Dialer) (*UDPTun, error) {
|
||||
addr := u.Host
|
||||
d := strings.Split(addr, "=")
|
||||
|
||||
p := &UDPTun{
|
||||
dialer: dialer,
|
||||
addr: d[0],
|
||||
taddr: d[1],
|
||||
ut := &UDPTun{
|
||||
proxy: p,
|
||||
addr: d[0],
|
||||
taddr: d[1],
|
||||
}
|
||||
|
||||
p.tuaddr, err = net.ResolveUDPAddr("udp", p.taddr)
|
||||
return p, err
|
||||
ut.tuaddr, err = net.ResolveUDPAddr("udp", ut.taddr)
|
||||
return ut, err
|
||||
}
|
||||
|
||||
// NewUDPTunServer returns a udp tunnel server.
|
||||
func NewUDPTunServer(s string, dialer proxy.Dialer) (proxy.Server, error) {
|
||||
return NewUDPTun(s, dialer)
|
||||
func NewUDPTunServer(s string, p proxy.Proxy) (proxy.Server, error) {
|
||||
return NewUDPTun(s, p)
|
||||
}
|
||||
|
||||
// ListenAndServe listen and serves on the given address.
|
||||
@@ -75,7 +75,7 @@ func (s *UDPTun) ListenAndServe() {
|
||||
|
||||
v, ok := nm.Load(raddr.String())
|
||||
if !ok && v == nil {
|
||||
pc, _, err = s.dialer.DialUDP("udp", s.taddr)
|
||||
pc, _, err = s.proxy.DialUDP("udp", s.taddr)
|
||||
if err != nil {
|
||||
log.F("[udptun] remote dial error: %v", err)
|
||||
continue
|
||||
|
||||
+14
-20
@@ -14,6 +14,7 @@ import (
|
||||
// Unix domain socket struct
|
||||
type Unix struct {
|
||||
dialer proxy.Dialer
|
||||
proxy proxy.Proxy
|
||||
addr string
|
||||
|
||||
server proxy.Server
|
||||
@@ -25,28 +26,29 @@ func init() {
|
||||
}
|
||||
|
||||
// NewUnix returns unix fomain socket proxy
|
||||
func NewUnix(s string, dialer proxy.Dialer) (*Unix, error) {
|
||||
func NewUnix(s string, d proxy.Dialer, p proxy.Proxy) (*Unix, error) {
|
||||
u, err := url.Parse(s)
|
||||
if err != nil {
|
||||
log.F("parse url err: %s", err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
p := &Unix{
|
||||
dialer: dialer,
|
||||
unix := &Unix{
|
||||
dialer: d,
|
||||
proxy: p,
|
||||
addr: u.Path,
|
||||
}
|
||||
|
||||
return p, nil
|
||||
return unix, nil
|
||||
}
|
||||
|
||||
// NewUnixDialer returns a unix domain socket dialer
|
||||
func NewUnixDialer(s string, dialer proxy.Dialer) (proxy.Dialer, error) {
|
||||
return NewUnix(s, dialer)
|
||||
func NewUnixDialer(s string, d proxy.Dialer) (proxy.Dialer, error) {
|
||||
return NewUnix(s, d, nil)
|
||||
}
|
||||
|
||||
// NewUnixServer returns a unix domain socket server
|
||||
func NewUnixServer(s string, dialer proxy.Dialer) (proxy.Server, error) {
|
||||
func NewUnixServer(s string, p proxy.Proxy) (proxy.Server, error) {
|
||||
transport := strings.Split(s, ",")
|
||||
|
||||
// prepare transport listener
|
||||
@@ -55,17 +57,17 @@ func NewUnixServer(s string, dialer proxy.Dialer) (proxy.Server, error) {
|
||||
return nil, errors.New("[unix] malformd listener:" + s)
|
||||
}
|
||||
|
||||
p, err := NewUnix(transport[0], dialer)
|
||||
unix, err := NewUnix(transport[0], nil, p)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
p.server, err = proxy.ServerFromURL(transport[1], dialer)
|
||||
unix.server, err = proxy.ServerFromURL(transport[1], p)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return p, nil
|
||||
return unix, nil
|
||||
}
|
||||
|
||||
// ListenAndServe serves requests
|
||||
@@ -109,18 +111,10 @@ func (s *Unix) Addr() string {
|
||||
return s.addr
|
||||
}
|
||||
|
||||
// NextDialer returns the next dialer
|
||||
func (s *Unix) NextDialer(dstAddr string) proxy.Dialer { return s.dialer.NextDialer(dstAddr) }
|
||||
|
||||
// Dial connects to the address addr on the network net via the proxy.
|
||||
func (s *Unix) Dial(network, addr string) (net.Conn, string, error) {
|
||||
func (s *Unix) Dial(network, addr string) (net.Conn, error) {
|
||||
// NOTE: must be the first dialer in a chain
|
||||
rc, err := net.Dial("unix", s.addr)
|
||||
if err != nil {
|
||||
return nil, "", err
|
||||
}
|
||||
|
||||
return rc, "", err
|
||||
return net.Dial("unix", s.addr)
|
||||
}
|
||||
|
||||
// DialUDP connects to the given address via the proxy
|
||||
|
||||
+11
-11
@@ -14,8 +14,8 @@ import (
|
||||
|
||||
// UoTTun is a base udp over tcp tunnel struct.
|
||||
type UoTTun struct {
|
||||
dialer proxy.Dialer
|
||||
addr string
|
||||
proxy proxy.Proxy
|
||||
addr string
|
||||
|
||||
raddr string
|
||||
}
|
||||
@@ -25,7 +25,7 @@ func init() {
|
||||
}
|
||||
|
||||
// NewUoTTun returns a UoTTun proxy.
|
||||
func NewUoTTun(s string, dialer proxy.Dialer) (*UoTTun, error) {
|
||||
func NewUoTTun(s string, p proxy.Proxy) (*UoTTun, error) {
|
||||
u, err := url.Parse(s)
|
||||
if err != nil {
|
||||
log.F("parse err: %s", err)
|
||||
@@ -35,18 +35,18 @@ func NewUoTTun(s string, dialer proxy.Dialer) (*UoTTun, error) {
|
||||
addr := u.Host
|
||||
d := strings.Split(addr, "=")
|
||||
|
||||
p := &UoTTun{
|
||||
dialer: dialer,
|
||||
addr: d[0],
|
||||
raddr: d[1],
|
||||
ut := &UoTTun{
|
||||
proxy: p,
|
||||
addr: d[0],
|
||||
raddr: d[1],
|
||||
}
|
||||
|
||||
return p, nil
|
||||
return ut, nil
|
||||
}
|
||||
|
||||
// NewUoTTunServer returns a uot tunnel server.
|
||||
func NewUoTTunServer(s string, dialer proxy.Dialer) (proxy.Server, error) {
|
||||
return NewUoTTun(s, dialer)
|
||||
func NewUoTTunServer(s string, p proxy.Proxy) (proxy.Server, error) {
|
||||
return NewUoTTun(s, p)
|
||||
}
|
||||
|
||||
// ListenAndServe listen and serve on tcp.
|
||||
@@ -69,7 +69,7 @@ func (s *UoTTun) ListenAndServe() {
|
||||
continue
|
||||
}
|
||||
|
||||
rc, p, err := s.dialer.Dial("uot", s.raddr)
|
||||
rc, p, err := s.proxy.Dial("uot", s.raddr)
|
||||
if err != nil {
|
||||
log.F("[uottun] failed to connect to server %v: %v", s.raddr, err)
|
||||
continue
|
||||
|
||||
+6
-10
@@ -27,7 +27,7 @@ func init() {
|
||||
}
|
||||
|
||||
// NewVMess returns a vmess proxy.
|
||||
func NewVMess(s string, dialer proxy.Dialer) (*VMess, error) {
|
||||
func NewVMess(s string, d proxy.Dialer) (*VMess, error) {
|
||||
u, err := url.Parse(s)
|
||||
if err != nil {
|
||||
log.F("parse url err: %s", err)
|
||||
@@ -62,7 +62,7 @@ func NewVMess(s string, dialer proxy.Dialer) (*VMess, error) {
|
||||
}
|
||||
|
||||
p := &VMess{
|
||||
dialer: dialer,
|
||||
dialer: d,
|
||||
addr: addr,
|
||||
uuid: uuid,
|
||||
alterID: int(alterID),
|
||||
@@ -86,18 +86,14 @@ func (s *VMess) Addr() string {
|
||||
return s.addr
|
||||
}
|
||||
|
||||
// NextDialer returns the next dialer
|
||||
func (s *VMess) NextDialer(dstAddr string) proxy.Dialer { return s.dialer.NextDialer(dstAddr) }
|
||||
|
||||
// Dial connects to the address addr on the network net via the proxy.
|
||||
func (s *VMess) Dial(network, addr string) (net.Conn, string, error) {
|
||||
rc, p, err := s.dialer.Dial("tcp", s.addr)
|
||||
func (s *VMess) Dial(network, addr string) (net.Conn, error) {
|
||||
rc, err := s.dialer.Dial("tcp", s.addr)
|
||||
if err != nil {
|
||||
return nil, p, err
|
||||
return nil, err
|
||||
}
|
||||
|
||||
cc, e := s.client.NewConn(rc, addr)
|
||||
return cc, p, e
|
||||
return s.client.NewConn(rc, addr)
|
||||
}
|
||||
|
||||
// DialUDP connects to the given address via the proxy.
|
||||
|
||||
+9
-13
@@ -24,7 +24,7 @@ func init() {
|
||||
}
|
||||
|
||||
// NewWS returns a websocket proxy.
|
||||
func NewWS(s string, dialer proxy.Dialer) (*WS, error) {
|
||||
func NewWS(s string, d proxy.Dialer) (*WS, error) {
|
||||
u, err := url.Parse(s)
|
||||
if err != nil {
|
||||
log.F("parse url err: %s", err)
|
||||
@@ -35,7 +35,7 @@ func NewWS(s string, dialer proxy.Dialer) (*WS, error) {
|
||||
|
||||
// TODO:
|
||||
if addr == "" {
|
||||
addr = dialer.Addr()
|
||||
addr = d.Addr()
|
||||
}
|
||||
|
||||
colonPos := strings.LastIndex(addr, ":")
|
||||
@@ -51,7 +51,7 @@ func NewWS(s string, dialer proxy.Dialer) (*WS, error) {
|
||||
}
|
||||
|
||||
p := &WS{
|
||||
dialer: dialer,
|
||||
dialer: d,
|
||||
addr: addr,
|
||||
client: client,
|
||||
}
|
||||
@@ -60,8 +60,8 @@ func NewWS(s string, dialer proxy.Dialer) (*WS, error) {
|
||||
}
|
||||
|
||||
// NewWSDialer returns a ws proxy dialer.
|
||||
func NewWSDialer(s string, dialer proxy.Dialer) (proxy.Dialer, error) {
|
||||
return NewWS(s, dialer)
|
||||
func NewWSDialer(s string, d proxy.Dialer) (proxy.Dialer, error) {
|
||||
return NewWS(s, d)
|
||||
}
|
||||
|
||||
// Addr returns forwarder's address.
|
||||
@@ -72,18 +72,14 @@ func (s *WS) Addr() string {
|
||||
return s.addr
|
||||
}
|
||||
|
||||
// NextDialer returns the next dialer.
|
||||
func (s *WS) NextDialer(dstAddr string) proxy.Dialer { return s.dialer.NextDialer(dstAddr) }
|
||||
|
||||
// Dial connects to the address addr on the network net via the proxy.
|
||||
func (s *WS) Dial(network, addr string) (net.Conn, string, error) {
|
||||
rc, p, err := s.dialer.Dial("tcp", s.addr)
|
||||
func (s *WS) Dial(network, addr string) (net.Conn, error) {
|
||||
rc, err := s.dialer.Dial("tcp", s.addr)
|
||||
if err != nil {
|
||||
return nil, p, err
|
||||
return nil, err
|
||||
}
|
||||
|
||||
cc, e := s.client.NewConn(rc, addr)
|
||||
return cc, p, e
|
||||
return s.client.NewConn(rc, addr)
|
||||
}
|
||||
|
||||
// DialUDP connects to the given address via the proxy.
|
||||
|
||||
Reference in new issue
Block a user