proxy: add a new interface proxy to distinguish client and server

This commit is contained in:
nadoo committed 2019-09-18 19:40:14 +08:00
1 parent 6c8141e43b
commit edcb21236a
27 files changed
+371 -398

No files matched your search

+6 -9
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
+15
View File
@@ -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
View File
@@ -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
+5 -8
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
+9 -9
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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.