add resolver for router

pkg/chain/router.go

@@ -3,16 +3,19 @@ package chain
 import (
 	"bytes"
 	"context"
+	"errors"
 	"fmt"
 	"net"
 
 	"github.com/go-gost/gost/pkg/connector"
 	"github.com/go-gost/gost/pkg/logger"
+	"github.com/go-gost/gost/pkg/resolver"
 )
 
 type Router struct {
-	chain   *Chain
 	retries  int
+	chain    *Chain
+	resolver resolver.Resolver
 	logger   logger.Logger
 }
 
@@ -21,6 +24,11 @@ func (r *Router) WithChain(chain *Chain) *Router {
 	return r
 }
 
+func (r *Router) WithResolver(resolver resolver.Resolver) *Router {
+	r.resolver = resolver
+	return r
+}
+
 func (r *Router) WithRetry(retries int) *Router {
 	r.retries = retries
 	return r
@@ -63,6 +71,12 @@ func (r *Router) dial(ctx context.Context, network, address string) (conn net.Co
 			r.logger.Debugf("route(retry=%d) %s", i, buf.String())
 		}
 
+		address, err = r.resolve(ctx, address)
+		if err != nil {
+			r.logger.Error(err)
+			break
+		}
+
 		conn, err = route.Dial(ctx, network, address)
 		if err == nil {
 			break
@@ -73,6 +87,31 @@ func (r *Router) dial(ctx context.Context, network, address string) (conn net.Co
 	return
 }
 
+func (r *Router) resolve(ctx context.Context, addr string) (string, error) {
+	host, port, err := net.SplitHostPort(addr)
+	if err != nil {
+		return "", err
+	}
+
+	/*
+		if ip := hosts.Lookup(host); ip != nil {
+			return net.JoinHostPort(ip.String(), port)
+		}
+	*/
+
+	if r.resolver != nil {
+		ips, err := r.resolver.Resolve(ctx, host)
+		if err != nil {
+			r.logger.Error(err)
+		}
+		if len(ips) == 0 {
+			return "", errors.New("domain not exists")
+		}
+		return net.JoinHostPort(ips[0].String(), port), nil
+	}
+	return addr, nil
+}
+
 func (r *Router) Bind(ctx context.Context, network, address string, opts ...connector.BindOption) (ln net.Listener, err error) {
 	count := r.retries + 1
 	if count <= 0 {

pkg/handler/http/handler.go

@@ -29,8 +29,8 @@ func init() {
 }
 
 type httpHandler struct {
-	chain  *chain.Chain
 	bypass bypass.Bypass
+	router *chain.Router
 	logger logger.Logger
 	md     metadata
 }
@@ -43,17 +43,26 @@ func NewHandler(opts ...handler.Option) handler.Handler {
 
 	return &httpHandler{
 		bypass: options.Bypass,
+		router: (&chain.Router{}).
+			WithLogger(options.Logger).
+			WithResolver(options.Resolver),
 		logger: options.Logger,
 	}
 }
 
 func (h *httpHandler) Init(md md.Metadata) error {
-	return h.parseMetadata(md)
+	if err := h.parseMetadata(md); err != nil {
+		return err
+	}
+
+	h.router.WithRetry(h.md.retryCount)
+
+	return nil
 }
 
 // implements chain.Chainable interface
 func (h *httpHandler) WithChain(chain *chain.Chain) {
-	h.chain = chain
+	h.router.WithChain(chain)
 }
 
 func (h *httpHandler) Handle(ctx context.Context, conn net.Conn) {
@@ -192,11 +201,7 @@ func (h *httpHandler) handleRequest(ctx context.Context, conn net.Conn, req *htt
 
 	req.Header.Del("Proxy-Authorization")
 
-	r := (&chain.Router{}).
+	cc, err := h.router.Dial(ctx, network, addr)
-		WithChain(h.chain).
-		WithRetry(h.md.retryCount).
-		WithLogger(h.logger)
-	cc, err := r.Dial(ctx, network, addr)
 	if err != nil {
 		resp.StatusCode = http.StatusServiceUnavailable
 		resp.Write(conn)

pkg/handler/http/udp.go

@@ -7,7 +7,6 @@ import (
 	"net/http/httputil"
 	"time"
 
-	"github.com/go-gost/gost/pkg/chain"
 	"github.com/go-gost/gost/pkg/common/util/socks"
 	"github.com/go-gost/gost/pkg/handler"
 	"github.com/go-gost/gost/pkg/logger"
@@ -51,11 +50,7 @@ func (h *httpHandler) handleUDP(ctx context.Context, conn net.Conn, network, add
 	}
 
 	// obtain a udp connection
-	r := (&chain.Router{}).
+	c, err := h.router.Dial(ctx, "udp", "") // UDP association
-		WithChain(h.chain).
-		WithRetry(h.md.retryCount).
-		WithLogger(h.logger)
-	c, err := r.Dial(ctx, "udp", "") // UDP association
 	if err != nil {
 		h.logger.Error(err)
 		return

pkg/handler/http2/handler.go

@@ -29,8 +29,8 @@ func init() {
 }
 
 type http2Handler struct {
-	chain  *chain.Chain
 	bypass bypass.Bypass
+	router *chain.Router
 	logger logger.Logger
 	md     metadata
 }
@@ -43,17 +43,26 @@ func NewHandler(opts ...handler.Option) handler.Handler {
 
 	return &http2Handler{
 		bypass: options.Bypass,
+		router: (&chain.Router{}).
+			WithLogger(options.Logger).
+			WithResolver(options.Resolver),
 		logger: options.Logger,
 	}
 }
 
 func (h *http2Handler) Init(md md.Metadata) error {
-	return h.parseMetadata(md)
+	if err := h.parseMetadata(md); err != nil {
+		return err
+	}
+
+	h.router.WithRetry(h.md.retryCount)
+
+	return nil
 }
 
 // implements chain.Chainable interface
 func (h *http2Handler) WithChain(chain *chain.Chain) {
-	h.chain = chain
+	h.router.WithChain(chain)
 }
 
 func (h *http2Handler) Handle(ctx context.Context, conn net.Conn) {
@@ -154,11 +163,7 @@ func (h *http2Handler) roundTrip(ctx context.Context, w http.ResponseWriter, req
 	req.Header.Del("Proxy-Authorization")
 	req.Header.Del("Proxy-Connection")
 
-	r := (&chain.Router{}).
+	cc, err := h.router.Dial(ctx, "tcp", addr)
-		WithChain(h.chain).
-		WithRetry(h.md.retryCount).
-		WithLogger(h.logger)
-	cc, err := r.Dial(ctx, "tcp", addr)
 	if err != nil {
 		h.logger.Error(err)
 		w.WriteHeader(http.StatusServiceUnavailable)
@@ -312,11 +317,7 @@ func (h *http2Handler) handleRequest(ctx context.Context, conn net.Conn, req *ht
 
 	req.Header.Del("Proxy-Authorization")
 
-	r := (&chain.Router{}).
+	cc, err := h.router.Dial(ctx, network, addr)
-		WithChain(h.chain).
-		WithRetry(h.md.retryCount).
-		WithLogger(h.logger)
-	cc, err := r.Dial(ctx, network, addr)
 	if err != nil {
 		resp.StatusCode = http.StatusServiceUnavailable
 		resp.Write(conn)

pkg/handler/option.go

@@ -3,10 +3,12 @@ package handler
 import (
 	"github.com/go-gost/gost/pkg/bypass"
 	"github.com/go-gost/gost/pkg/logger"
+	"github.com/go-gost/gost/pkg/resolver"
 )
 
 type Options struct {
 	Bypass   bypass.Bypass
+	Resolver resolver.Resolver
 	Logger   logger.Logger
 }
 
@@ -23,3 +25,9 @@ func BypassOption(bypass bypass.Bypass) Option {
 		opts.Bypass = bypass
 	}
 }
+
+func ResolverOption(resolver resolver.Resolver) Option {
+	return func(opts *Options) {
+		opts.Resolver = resolver
+	}
+}

pkg/handler/relay/connect.go

@@ -6,7 +6,6 @@ import (
 	"net"
 	"time"
 
-	"github.com/go-gost/gost/pkg/chain"
 	"github.com/go-gost/gost/pkg/handler"
 	"github.com/go-gost/relay"
 )
@@ -38,11 +37,7 @@ func (h *relayHandler) handleConnect(ctx context.Context, conn net.Conn, network
 		return
 	}
 
-	r := (&chain.Router{}).
+	cc, err := h.router.Dial(ctx, network, address)
-		WithChain(h.chain).
-		WithRetry(h.md.retryCount).
-		WithLogger(h.logger)
-	cc, err := r.Dial(ctx, network, address)
 	if err != nil {
 		resp.Status = relay.StatusNetworkUnreachable
 		resp.WriteTo(conn)

pkg/handler/relay/forward.go

@@ -6,7 +6,6 @@ import (
 	"net"
 	"time"
 
-	"github.com/go-gost/gost/pkg/chain"
 	"github.com/go-gost/gost/pkg/handler"
 	"github.com/go-gost/relay"
 )
@@ -30,12 +29,7 @@ func (h *relayHandler) handleForward(ctx context.Context, conn net.Conn, network
 
 	h.logger.Infof("%s >> %s", conn.RemoteAddr(), target.Addr())
 
-	r := (&chain.Router{}).
+	cc, err := h.router.Dial(ctx, network, target.Addr())
-		WithChain(h.chain).
-		WithRetry(h.md.retryCount).
-		WithLogger(h.logger)
-
-	cc, err := r.Dial(ctx, network, target.Addr())
 	if err != nil {
 		// TODO: the router itself may be failed due to the failed node in the router,
 		// the dead marker may be a wrong operation.

pkg/handler/relay/handler.go

@@ -21,8 +21,8 @@ func init() {
 
 type relayHandler struct {
 	group  *chain.NodeGroup
-	chain  *chain.Chain
 	bypass bypass.Bypass
+	router *chain.Router
 	logger logger.Logger
 	md     metadata
 }
@@ -35,17 +35,26 @@ func NewHandler(opts ...handler.Option) handler.Handler {
 
 	return &relayHandler{
 		bypass: options.Bypass,
+		router: (&chain.Router{}).
+			WithLogger(options.Logger).
+			WithResolver(options.Resolver),
 		logger: options.Logger,
 	}
 }
 
 func (h *relayHandler) Init(md md.Metadata) (err error) {
-	return h.parseMetadata(md)
+	if err := h.parseMetadata(md); err != nil {
+		return err
+	}
+
+	h.router.WithRetry(h.md.retryCount)
+
+	return nil
 }
 
 // WithChain implements chain.Chainable interface
 func (h *relayHandler) WithChain(chain *chain.Chain) {
-	h.chain = chain
+	h.router.WithChain(chain)
 }
 
 // Forward implements handler.Forwarder.

pkg/handler/sni/handler.go

@@ -27,8 +27,8 @@ func init() {
 
 type sniHandler struct {
 	httpHandler handler.Handler
-	chain       *chain.Chain
 	bypass      bypass.Bypass
+	router      *chain.Router
 	logger      logger.Logger
 	md          metadata
 }
@@ -46,6 +46,9 @@ func NewHandler(opts ...handler.Option) handler.Handler {
 
 	h := &sniHandler{
 		bypass: options.Bypass,
+		router: (&chain.Router{}).
+			WithLogger(options.Logger).
+			WithResolver(options.Resolver),
 		logger: log,
 	}
 
@@ -71,12 +74,14 @@ func (h *sniHandler) Init(md md.Metadata) (err error) {
 		}
 	}
 
+	h.router.WithRetry(h.md.retryCount)
+
 	return nil
 }
 
 // WithChain implements chain.Chainable interface
 func (h *sniHandler) WithChain(chain *chain.Chain) {
-	h.chain = chain
+	h.router.WithChain(chain)
 }
 
 func (h *sniHandler) Handle(ctx context.Context, conn net.Conn) {
@@ -141,11 +146,7 @@ func (h *sniHandler) Handle(ctx context.Context, conn net.Conn) {
 		return
 	}
 
-	r := (&chain.Router{}).
+	cc, err := h.router.Dial(ctx, "tcp", target)
-		WithChain(h.chain).
-		WithRetry(h.md.retryCount).
-		WithLogger(h.logger)
-	cc, err := r.Dial(ctx, "tcp", target)
 	if err != nil {
 		return
 	}

pkg/handler/socks/v4/handler.go

@@ -20,8 +20,8 @@ func init() {
 }
 
 type socks4Handler struct {
-	chain  *chain.Chain
 	bypass bypass.Bypass
+	router *chain.Router
 	logger logger.Logger
 	md     metadata
 }
@@ -34,17 +34,26 @@ func NewHandler(opts ...handler.Option) handler.Handler {
 
 	return &socks4Handler{
 		bypass: options.Bypass,
+		router: (&chain.Router{}).
+			WithLogger(options.Logger).
+			WithResolver(options.Resolver),
 		logger: options.Logger,
 	}
 }
 
 func (h *socks4Handler) Init(md md.Metadata) (err error) {
-	return h.parseMetadata(md)
+	if err := h.parseMetadata(md); err != nil {
+		return err
+	}
+
+	h.router.WithRetry(h.md.retryCount)
+
+	return nil
 }
 
 // implements chain.Chainable interface
 func (h *socks4Handler) WithChain(chain *chain.Chain) {
-	h.chain = chain
+	h.router.WithChain(chain)
 }
 
 func (h *socks4Handler) Handle(ctx context.Context, conn net.Conn) {
@@ -111,11 +120,7 @@ func (h *socks4Handler) handleConnect(ctx context.Context, conn net.Conn, req *g
 		return
 	}
 
-	r := (&chain.Router{}).
+	cc, err := h.router.Dial(ctx, "tcp", addr)
-		WithChain(h.chain).
-		WithRetry(h.md.retryCount).
-		WithLogger(h.logger)
-	cc, err := r.Dial(ctx, "tcp", addr)
 	if err != nil {
 		resp := gosocks4.NewReply(gosocks4.Failed, nil)
 		resp.Write(conn)

pkg/handler/socks/v5/connect.go

@@ -7,7 +7,6 @@ import (
 	"time"
 
 	"github.com/go-gost/gosocks5"
-	"github.com/go-gost/gost/pkg/chain"
 	"github.com/go-gost/gost/pkg/handler"
 )
 
@@ -26,11 +25,7 @@ func (h *socks5Handler) handleConnect(ctx context.Context, conn net.Conn, networ
 		return
 	}
 
-	r := (&chain.Router{}).
+	cc, err := h.router.Dial(ctx, network, address)
-		WithChain(h.chain).
-		WithRetry(h.md.retryCount).
-		WithLogger(h.logger)
-	cc, err := r.Dial(ctx, network, address)
 	if err != nil {
 		resp := gosocks5.NewReply(gosocks5.NetUnreachable, nil)
 		resp.Write(conn)

pkg/handler/socks/v5/handler.go

@@ -22,8 +22,8 @@ func init() {
 
 type socks5Handler struct {
 	selector gosocks5.Selector
-	chain    *chain.Chain
 	bypass   bypass.Bypass
+	router   *chain.Router
 	logger   logger.Logger
 	md       metadata
 }
@@ -36,6 +36,9 @@ func NewHandler(opts ...handler.Option) handler.Handler {
 
 	return &socks5Handler{
 		bypass: options.Bypass,
+		router: (&chain.Router{}).
+			WithLogger(options.Logger).
+			WithResolver(options.Resolver),
 		logger: options.Logger,
 	}
 }
@@ -52,12 +55,14 @@ func (h *socks5Handler) Init(md md.Metadata) (err error) {
 		noTLS:         h.md.noTLS,
 	}
 
+	h.router.WithRetry(h.md.retryCount)
+
 	return
 }
 
 // implements chain.Chainable interface
 func (h *socks5Handler) WithChain(chain *chain.Chain) {
-	h.chain = chain
+	h.router.WithChain(chain)
 }
 
 func (h *socks5Handler) Handle(ctx context.Context, conn net.Conn) {

pkg/handler/socks/v5/udp.go

@@ -9,7 +9,6 @@ import (
 	"time"
 
 	"github.com/go-gost/gosocks5"
-	"github.com/go-gost/gost/pkg/chain"
 	"github.com/go-gost/gost/pkg/common/util/socks"
 	"github.com/go-gost/gost/pkg/handler"
 )
@@ -54,11 +53,7 @@ func (h *socks5Handler) handleUDP(ctx context.Context, conn net.Conn) {
 	h.logger.Debugf("bind on %s OK", cc.LocalAddr())
 
 	// obtain a udp connection
-	r := (&chain.Router{}).
+	c, err := h.router.Dial(ctx, "udp", "") // UDP association
-		WithChain(h.chain).
-		WithRetry(h.md.retryCount).
-		WithLogger(h.logger)
-	c, err := r.Dial(ctx, "udp", "") // UDP association
 	if err != nil {
 		h.logger.Error(err)
 		return

pkg/handler/socks/v5/udp_tun.go

@@ -6,7 +6,6 @@ import (
 	"time"
 
 	"github.com/go-gost/gosocks5"
-	"github.com/go-gost/gost/pkg/chain"
 	"github.com/go-gost/gost/pkg/common/util/socks"
 	"github.com/go-gost/gost/pkg/handler"
 )
@@ -33,11 +32,7 @@ func (h *socks5Handler) handleUDPTun(ctx context.Context, conn net.Conn, network
 	h.logger.Debug(reply)
 
 	// obtain a udp connection
-	r := (&chain.Router{}).
+	c, err := h.router.Dial(ctx, "udp", "") // UDP association
-		WithChain(h.chain).
-		WithRetry(h.md.retryCount).
-		WithLogger(h.logger)
-	c, err := r.Dial(ctx, "udp", "") // UDP association
 	if err != nil {
 		h.logger.Error(err)
 		return

pkg/handler/ss/handler.go

@@ -22,8 +22,8 @@ func init() {
 }
 
 type ssHandler struct {
-	chain  *chain.Chain
 	bypass bypass.Bypass
+	router *chain.Router
 	logger logger.Logger
 	md     metadata
 }
@@ -36,17 +36,26 @@ func NewHandler(opts ...handler.Option) handler.Handler {
 
 	return &ssHandler{
 		bypass: options.Bypass,
+		router: (&chain.Router{}).
+			WithLogger(options.Logger).
+			WithResolver(options.Resolver),
 		logger: options.Logger,
 	}
 }
 
 func (h *ssHandler) Init(md md.Metadata) (err error) {
-	return h.parseMetadata(md)
+	if err := h.parseMetadata(md); err != nil {
+		return err
+	}
+
+	h.router.WithRetry(h.md.retryCount)
+
+	return nil
 }
 
 // implements chain.Chainable interface
 func (h *ssHandler) WithChain(chain *chain.Chain) {
-	h.chain = chain
+	h.router.WithChain(chain)
 }
 
 func (h *ssHandler) Handle(ctx context.Context, conn net.Conn) {
@@ -91,11 +100,7 @@ func (h *ssHandler) Handle(ctx context.Context, conn net.Conn) {
 		return
 	}
 
-	r := (&chain.Router{}).
+	cc, err := h.router.Dial(ctx, "tcp", addr.String())
-		WithChain(h.chain).
-		WithRetry(h.md.retryCount).
-		WithLogger(h.logger)
-	cc, err := r.Dial(ctx, "tcp", addr.String())
 	if err != nil {
 		return
 	}

pkg/handler/ss/udp/handler.go

@@ -21,8 +21,8 @@ func init() {
 }
 
 type ssuHandler struct {
-	chain  *chain.Chain
 	bypass bypass.Bypass
+	router *chain.Router
 	logger logger.Logger
 	md     metadata
 }
@@ -35,17 +35,26 @@ func NewHandler(opts ...handler.Option) handler.Handler {
 
 	return &ssuHandler{
 		bypass: options.Bypass,
+		router: (&chain.Router{}).
+			WithLogger(options.Logger).
+			WithResolver(options.Resolver),
 		logger: options.Logger,
 	}
 }
 
 func (h *ssuHandler) Init(md md.Metadata) (err error) {
-	return h.parseMetadata(md)
+	if err := h.parseMetadata(md); err != nil {
+		return err
+	}
+
+	h.router.WithRetry(h.md.retryCount)
+
+	return nil
 }
 
 // WithChain implements chain.Chainable interface
 func (h *ssuHandler) WithChain(chain *chain.Chain) {
-	h.chain = chain
+	h.router.WithChain(chain)
 }
 
 func (h *ssuHandler) Handle(ctx context.Context, conn net.Conn) {
@@ -80,11 +89,7 @@ func (h *ssuHandler) Handle(ctx context.Context, conn net.Conn) {
 	}
 
 	// obtain a udp connection
-	r := (&chain.Router{}).
+	c, err := h.router.Dial(ctx, "udp", "") // UDP association
-		WithChain(h.chain).
-		WithRetry(h.md.retryCount).
-		WithLogger(h.logger)
-	c, err := r.Dial(ctx, "udp", "") // UDP association
 	if err != nil {
 		h.logger.Error(err)
 		return

pkg/handler/tap/handler.go

@@ -20,7 +20,6 @@ import (
 	"github.com/go-gost/gost/pkg/registry"
 	"github.com/shadowsocks/go-shadowsocks2/shadowaead"
 	"github.com/songgao/water/waterutil"
-	"github.com/xtaci/tcpraw"
 )
 
 func init() {
@@ -29,10 +28,10 @@ func init() {
 
 type tapHandler struct {
 	group  *chain.NodeGroup
-	chain  *chain.Chain
 	bypass bypass.Bypass
 	routes sync.Map
 	exit   chan struct{}
+	router *chain.Router
 	logger logger.Logger
 	md     metadata
 }
@@ -45,18 +44,27 @@ func NewHandler(opts ...handler.Option) handler.Handler {
 
 	return &tapHandler{
 		bypass: options.Bypass,
-		exit:   make(chan struct{}, 1),
+		router: (&chain.Router{}).
+			WithLogger(options.Logger).
+			WithResolver(options.Resolver),
 		logger: options.Logger,
+		exit:   make(chan struct{}, 1),
 	}
 }
 
 func (h *tapHandler) Init(md md.Metadata) (err error) {
-	return h.parseMetadata(md)
+	if err := h.parseMetadata(md); err != nil {
+		return err
+	}
+
+	h.router.WithRetry(h.md.retryCount)
+
+	return nil
 }
 
 // implements chain.Chainable interface
 func (h *tapHandler) WithChain(chain *chain.Chain) {
-	h.chain = chain
+	h.router.WithChain(chain)
 }
 
 // Forward implements handler.Forwarder.
@@ -113,13 +121,9 @@ func (h *tapHandler) handleLoop(ctx context.Context, conn net.Conn, addr net.Add
 		err := func() error {
 			var err error
 			var pc net.PacketConn
-			// fake tcp mode will be ignored when the client specifies a chain.
+
-			if addr != nil && !h.chain.IsEmpty() {
+			if addr != nil {
-				r := (&chain.Router{}).
+				cc, err := h.router.Dial(ctx, addr.Network(), addr.String())
-					WithChain(h.chain).
-					WithRetry(h.md.retryCount).
-					WithLogger(h.logger)
-				cc, err := r.Dial(ctx, addr.Network(), addr.String())
 				if err != nil {
 					return err
 				}
@@ -129,18 +133,10 @@ func (h *tapHandler) handleLoop(ctx context.Context, conn net.Conn, addr net.Add
 				if !ok {
 					return errors.New("invalid connection")
 				}
-			} else {
-				if h.md.tcpMode {
-					if addr != nil {
-						pc, err = tcpraw.Dial("tcp", addr.String())
-					} else {
-						pc, err = tcpraw.Listen("tcp", conn.LocalAddr().String())
-					}
 			} else {
 				laddr, _ := net.ResolveUDPAddr("udp", conn.LocalAddr().String())
 				pc, err = net.ListenUDP("udp", laddr)
 			}
-			}
 			if err != nil {
 				return err
 			}

pkg/handler/tap/metadata.go

@@ -11,7 +11,6 @@ import (
 type metadata struct {
 	cipher     core.Cipher
 	retryCount int
-	tcpMode    bool
 	bufferSize int
 }
 
@@ -21,7 +20,6 @@ func (h *tapHandler) parseMetadata(md mdata.Metadata) (err error) {
 		key         = "key"
 		readTimeout = "readTimeout"
 		retryCount  = "retry"
-		tcpMode     = "tcp"
 		bufferSize  = "bufferSize"
 	)
 
@@ -40,7 +38,6 @@ func (h *tapHandler) parseMetadata(md mdata.Metadata) (err error) {
 		return
 	}
 	h.md.retryCount = mdata.GetInt(md, retryCount)
-	h.md.tcpMode = mdata.GetBool(md, tcpMode)
 
 	h.md.bufferSize = mdata.GetInt(md, bufferSize)
 	if h.md.bufferSize <= 0 {

pkg/handler/tun/handler.go

@@ -20,7 +20,6 @@ import (
 	"github.com/go-gost/gost/pkg/registry"
 	"github.com/shadowsocks/go-shadowsocks2/shadowaead"
 	"github.com/songgao/water/waterutil"
-	"github.com/xtaci/tcpraw"
 	"golang.org/x/net/ipv4"
 	"golang.org/x/net/ipv6"
 )
@@ -31,10 +30,10 @@ func init() {
 
 type tunHandler struct {
 	group  *chain.NodeGroup
-	chain  *chain.Chain
 	bypass bypass.Bypass
 	routes sync.Map
 	exit   chan struct{}
+	router *chain.Router
 	logger logger.Logger
 	md     metadata
 }
@@ -47,18 +46,27 @@ func NewHandler(opts ...handler.Option) handler.Handler {
 
 	return &tunHandler{
 		bypass: options.Bypass,
-		exit:   make(chan struct{}, 1),
+		router: (&chain.Router{}).
+			WithLogger(options.Logger).
+			WithResolver(options.Resolver),
 		logger: options.Logger,
+		exit:   make(chan struct{}, 1),
 	}
 }
 
 func (h *tunHandler) Init(md md.Metadata) (err error) {
-	return h.parseMetadata(md)
+	if err := h.parseMetadata(md); err != nil {
+		return err
+	}
+
+	h.router.WithRetry(h.md.retryCount)
+
+	return nil
 }
 
 // implements chain.Chainable interface
 func (h *tunHandler) WithChain(chain *chain.Chain) {
-	h.chain = chain
+	h.router.WithChain(chain)
 }
 
 // Forward implements handler.Forwarder.
@@ -115,13 +123,8 @@ func (h *tunHandler) handleLoop(ctx context.Context, conn net.Conn, addr net.Add
 		err := func() error {
 			var err error
 			var pc net.PacketConn
-			// fake tcp mode will be ignored when the client specifies a chain.
+			if addr != nil {
-			if addr != nil && !h.chain.IsEmpty() {
+				cc, err := h.router.Dial(ctx, addr.Network(), addr.String())
-				r := (&chain.Router{}).
-					WithChain(h.chain).
-					WithRetry(h.md.retryCount).
-					WithLogger(h.logger)
-				cc, err := r.Dial(ctx, addr.Network(), addr.String())
 				if err != nil {
 					return err
 				}
@@ -131,18 +134,10 @@ func (h *tunHandler) handleLoop(ctx context.Context, conn net.Conn, addr net.Add
 				if !ok {
 					return errors.New("invalid connnection")
 				}
-			} else {
-				if h.md.tcpMode {
-					if addr != nil {
-						pc, err = tcpraw.Dial("tcp", addr.String())
-					} else {
-						pc, err = tcpraw.Listen("tcp", conn.LocalAddr().String())
-					}
 			} else {
 				laddr, _ := net.ResolveUDPAddr("udp", conn.LocalAddr().String())
 				pc, err = net.ListenUDP("udp", laddr)
 			}
-			}
 			if err != nil {
 				return err
 			}

pkg/handler/tun/metadata.go

@@ -11,7 +11,6 @@ import (
 type metadata struct {
 	cipher     core.Cipher
 	retryCount int
-	tcpMode    bool
 	bufferSize int
 }
 
@@ -21,7 +20,6 @@ func (h *tunHandler) parseMetadata(md mdata.Metadata) (err error) {
 		key         = "key"
 		readTimeout = "readTimeout"
 		retryCount  = "retry"
-		tcpMode     = "tcp"
 		bufferSize  = "bufferSize"
 	)
 
@@ -40,7 +38,6 @@ func (h *tunHandler) parseMetadata(md mdata.Metadata) (err error) {
 		return
 	}
 	h.md.retryCount = mdata.GetInt(md, retryCount)
-	h.md.tcpMode = mdata.GetBool(md, tcpMode)
 
 	h.md.bufferSize = mdata.GetInt(md, bufferSize)
 	if h.md.bufferSize <= 0 {

pkg/resolver/impl/resolver.go

@@ -0,0 +1,176 @@
+package impl
+
+import (
+	"context"
+	"net"
+	"strings"
+	"time"
+
+	"github.com/go-gost/gost/pkg/chain"
+	resolver_util "github.com/go-gost/gost/pkg/internal/util/resolver"
+	"github.com/go-gost/gost/pkg/logger"
+	resolverpkg "github.com/go-gost/gost/pkg/resolver"
+	"github.com/go-gost/gost/pkg/resolver/exchanger"
+	"github.com/miekg/dns"
+)
+
+type NameServer struct {
+	Addr      string
+	Chain     *chain.Chain
+	TTL       time.Duration
+	Timeout   time.Duration
+	ClientIP  net.IP
+	Prefer    string
+	Hostname  string // for TLS handshake verification
+	exchanger exchanger.Exchanger
+}
+
+type resolverOptions struct {
+	domain string
+	logger logger.Logger
+}
+
+type ResolverOption func(opts *resolverOptions)
+
+func DomainResolverOption(domain string) ResolverOption {
+	return func(opts *resolverOptions) {
+		opts.domain = domain
+	}
+}
+
+func LoggerResolverOption(logger logger.Logger) ResolverOption {
+	return func(opts *resolverOptions) {
+		opts.logger = logger
+	}
+}
+
+type resolver struct {
+	servers []NameServer
+	cache   *resolver_util.Cache
+	options resolverOptions
+	logger  logger.Logger
+}
+
+func NewResolver(nameservers []NameServer, opts ...ResolverOption) (resolverpkg.Resolver, error) {
+	options := resolverOptions{}
+	for _, opt := range opts {
+		opt(&options)
+	}
+
+	var servers []NameServer
+	for _, server := range nameservers {
+		addr := strings.TrimSpace(server.Addr)
+		if addr == "" {
+			continue
+		}
+		ex, err := exchanger.NewExchanger(
+			addr,
+			exchanger.ChainOption(server.Chain),
+			exchanger.TimeoutOption(server.Timeout),
+			exchanger.LoggerOption(options.logger),
+		)
+		if err != nil {
+			options.logger.Warnf("parse %s: %v", server, err)
+			continue
+		}
+
+		server.exchanger = ex
+		servers = append(servers, server)
+	}
+	cache := resolver_util.NewCache().
+		WithLogger(options.logger)
+
+	return &resolver{
+		servers: servers,
+		cache:   cache,
+		options: options,
+		logger:  options.logger,
+	}, nil
+}
+
+func (r *resolver) Resolve(ctx context.Context, host string) (ips []net.IP, err error) {
+	if ip := net.ParseIP(host); ip != nil {
+		return []net.IP{ip}, nil
+	}
+
+	if r.options.domain != "" &&
+		!strings.Contains(host, ".") {
+		host = host + "." + r.options.domain
+	}
+
+	for _, server := range r.servers {
+		ips, err = r.resolve(ctx, &server, host)
+		if err != nil {
+			r.logger.Error(err)
+			continue
+		}
+
+		r.logger.Debugf("resolve %s via %s: %v", host, server.exchanger.String(), ips)
+
+		if len(ips) > 0 {
+			break
+		}
+	}
+
+	return
+}
+
+func (r *resolver) resolve(ctx context.Context, server *NameServer, host string) (ips []net.IP, err error) {
+	if server == nil {
+		return
+	}
+
+	if server.Prefer == "ipv6" { // prefer ipv6
+		mq := dns.Msg{}
+		mq.SetQuestion(dns.Fqdn(host), dns.TypeAAAA)
+		ips, err = r.resolveIPs(ctx, server, &mq)
+		if err != nil || len(ips) > 0 {
+			return
+		}
+	}
+
+	// fallback to ipv4
+	mq := dns.Msg{}
+	mq.SetQuestion(dns.Fqdn(host), dns.TypeA)
+	return r.resolveIPs(ctx, server, &mq)
+}
+
+func (r *resolver) resolveIPs(ctx context.Context, server *NameServer, mq *dns.Msg) (ips []net.IP, err error) {
+	key := resolver_util.NewCacheKey(&mq.Question[0])
+	mr := r.cache.Load(key)
+	if mr == nil {
+		resolver_util.AddSubnetOpt(mq, server.ClientIP)
+		mr, err = r.exchange(ctx, server.exchanger, mq)
+		if err != nil {
+			return
+		}
+		r.cache.Store(key, mr, server.TTL)
+	}
+
+	for _, ans := range mr.Answer {
+		if ar, _ := ans.(*dns.AAAA); ar != nil {
+			ips = append(ips, ar.AAAA)
+		}
+		if ar, _ := ans.(*dns.A); ar != nil {
+			ips = append(ips, ar.A)
+		}
+	}
+
+	return
+}
+
+func (r *resolver) exchange(ctx context.Context, ex exchanger.Exchanger, mq *dns.Msg) (mr *dns.Msg, err error) {
+	query, err := mq.Pack()
+	if err != nil {
+		return
+	}
+	reply, err := ex.Exchange(ctx, query)
+	if err != nil {
+		return
+	}
+
+	mr = &dns.Msg{}
+	err = mr.Unpack(reply)
+
+	return
+}

pkg/resolver/resolver.go

@@ -3,178 +3,9 @@ package resolver
 import (
 	"context"
 	"net"
-	"strings"
-	"time"
-
-	"github.com/go-gost/gost/pkg/chain"
-	resolver_util "github.com/go-gost/gost/pkg/internal/util/resolver"
-	"github.com/go-gost/gost/pkg/logger"
-	"github.com/go-gost/gost/pkg/resolver/exchanger"
-	"github.com/miekg/dns"
 )
 
 type Resolver interface {
 	// Resolve returns a slice of the host's IPv4 and IPv6 addresses.
 	Resolve(ctx context.Context, host string) ([]net.IP, error)
 }
-
-type NameServer struct {
-	Addr      string
-	Chain     *chain.Chain
-	TTL       time.Duration
-	Timeout   time.Duration
-	ClientIP  net.IP
-	Prefer    string
-	Hostname  string // for TLS handshake verification
-	exchanger exchanger.Exchanger
-}
-
-type resolverOptions struct {
-	domain string
-	logger logger.Logger
-}
-
-type ResolverOption func(opts *resolverOptions)
-
-func DomainResolverOption(domain string) ResolverOption {
-	return func(opts *resolverOptions) {
-		opts.domain = domain
-	}
-}
-
-func LoggerResolverOption(logger logger.Logger) ResolverOption {
-	return func(opts *resolverOptions) {
-		opts.logger = logger
-	}
-}
-
-type resolver struct {
-	servers []NameServer
-	cache   *resolver_util.Cache
-	options resolverOptions
-	logger  logger.Logger
-}
-
-func NewResolver(nameservers []NameServer, opts ...ResolverOption) (Resolver, error) {
-	options := resolverOptions{}
-	for _, opt := range opts {
-		opt(&options)
-	}
-
-	var servers []NameServer
-	for _, server := range nameservers {
-		addr := strings.TrimSpace(server.Addr)
-		if addr == "" {
-			continue
-		}
-		ex, err := exchanger.NewExchanger(
-			addr,
-			exchanger.ChainOption(server.Chain),
-			exchanger.TimeoutOption(server.Timeout),
-			exchanger.LoggerOption(options.logger),
-		)
-		if err != nil {
-			options.logger.Warnf("parse %s: %v", server, err)
-			continue
-		}
-
-		server.exchanger = ex
-		servers = append(servers, server)
-	}
-	cache := resolver_util.NewCache().
-		WithLogger(options.logger)
-
-	return &resolver{
-		servers: servers,
-		cache:   cache,
-		options: options,
-		logger:  options.logger,
-	}, nil
-}
-
-func (r *resolver) Resolve(ctx context.Context, host string) (ips []net.IP, err error) {
-	if ip := net.ParseIP(host); ip != nil {
-		return []net.IP{ip}, nil
-	}
-
-	if r.options.domain != "" &&
-		!strings.Contains(host, ".") {
-		host = host + "." + r.options.domain
-	}
-
-	for _, server := range r.servers {
-		ips, err = r.resolve(ctx, &server, host)
-		if err != nil {
-			r.logger.Error(err)
-			continue
-		}
-
-		r.logger.Debugf("resolve %s via %s: %v", host, server.exchanger.String(), ips)
-
-		if len(ips) > 0 {
-			break
-		}
-	}
-
-	return
-}
-
-func (r *resolver) resolve(ctx context.Context, server *NameServer, host string) (ips []net.IP, err error) {
-	if server == nil {
-		return
-	}
-
-	if server.Prefer == "ipv6" { // prefer ipv6
-		mq := dns.Msg{}
-		mq.SetQuestion(dns.Fqdn(host), dns.TypeAAAA)
-		ips, err = r.resolveIPs(ctx, server, &mq)
-		if err != nil || len(ips) > 0 {
-			return
-		}
-	}
-
-	// fallback to ipv4
-	mq := dns.Msg{}
-	mq.SetQuestion(dns.Fqdn(host), dns.TypeA)
-	return r.resolveIPs(ctx, server, &mq)
-}
-
-func (r *resolver) resolveIPs(ctx context.Context, server *NameServer, mq *dns.Msg) (ips []net.IP, err error) {
-	key := resolver_util.NewCacheKey(&mq.Question[0])
-	mr := r.cache.Load(key)
-	if mr == nil {
-		resolver_util.AddSubnetOpt(mq, server.ClientIP)
-		mr, err = r.exchange(ctx, server.exchanger, mq)
-		if err != nil {
-			return
-		}
-		r.cache.Store(key, mr, server.TTL)
-	}
-
-	for _, ans := range mr.Answer {
-		if ar, _ := ans.(*dns.AAAA); ar != nil {
-			ips = append(ips, ar.AAAA)
-		}
-		if ar, _ := ans.(*dns.A); ar != nil {
-			ips = append(ips, ar.A)
-		}
-	}
-
-	return
-}
-
-func (r *resolver) exchange(ctx context.Context, ex exchanger.Exchanger, mq *dns.Msg) (mr *dns.Msg, err error) {
-	query, err := mq.Pack()
-	if err != nil {
-		return
-	}
-	reply, err := ex.Exchange(ctx, query)
-	if err != nil {
-		return
-	}
-
-	mr = &dns.Msg{}
-	err = mr.Unpack(reply)
-
-	return
-}