fix log usage

cmd/gost/register.go

@@ -3,7 +3,6 @@ package main
 import (
 	// Register connectors
 	_ "github.com/go-gost/gost/pkg/connector/forward"
-	_ "github.com/go-gost/gost/pkg/connector/forward/ssh"
 	_ "github.com/go-gost/gost/pkg/connector/http"
 	_ "github.com/go-gost/gost/pkg/connector/http2"
 	_ "github.com/go-gost/gost/pkg/connector/relay"
@@ -12,9 +11,9 @@ import (
 	_ "github.com/go-gost/gost/pkg/connector/socks/v5"
 	_ "github.com/go-gost/gost/pkg/connector/ss"
 	_ "github.com/go-gost/gost/pkg/connector/ss/udp"
+	_ "github.com/go-gost/gost/pkg/connector/sshd"
 
 	// Register dialers
-	_ "github.com/go-gost/gost/pkg/dialer/forward/ssh"
 	_ "github.com/go-gost/gost/pkg/dialer/ftcp"
 	_ "github.com/go-gost/gost/pkg/dialer/http2"
 	_ "github.com/go-gost/gost/pkg/dialer/http2/h2"
@@ -25,6 +24,7 @@ import (
 	_ "github.com/go-gost/gost/pkg/dialer/pht"
 	_ "github.com/go-gost/gost/pkg/dialer/quic"
 	_ "github.com/go-gost/gost/pkg/dialer/ssh"
+	_ "github.com/go-gost/gost/pkg/dialer/sshd"
 	_ "github.com/go-gost/gost/pkg/dialer/tcp"
 	_ "github.com/go-gost/gost/pkg/dialer/tls"
 	_ "github.com/go-gost/gost/pkg/dialer/tls/mux"

pkg/connector/forward/connector.go

@@ -5,7 +5,6 @@ import (
 	"net"
 
 	"github.com/go-gost/gost/pkg/connector"
-	"github.com/go-gost/gost/pkg/logger"
 	md "github.com/go-gost/gost/pkg/metadata"
 	"github.com/go-gost/gost/pkg/registry"
 )
@@ -15,17 +14,17 @@ func init() {
 }
 
 type forwardConnector struct {
-	logger logger.Logger
+	options connector.Options
 }
 
 func NewConnector(opts ...connector.Option) connector.Connector {
-	options := &connector.Options{}
+	options := connector.Options{}
 	for _, opt := range opts {
-		opt(options)
+		opt(&options)
 	}
 
 	return &forwardConnector{
-		logger: options.Logger,
+		options: options,
 	}
 }
 
@@ -34,13 +33,13 @@ func (c *forwardConnector) Init(md md.Metadata) (err error) {
 }
 
 func (c *forwardConnector) Connect(ctx context.Context, conn net.Conn, network, address string, opts ...connector.ConnectOption) (net.Conn, error) {
-	c.logger = c.logger.WithFields(map[string]interface{}{
+	log := c.options.Logger.WithFields(map[string]interface{}{
 		"remote":  conn.RemoteAddr().String(),
 		"local":   conn.LocalAddr().String(),
 		"network": network,
 		"address": address,
 	})
-	c.logger.Infof("connect %s/%s", address, network)
+	log.Infof("connect %s/%s", address, network)
 
 	return conn, nil
 }

pkg/connector/http/connector.go

@@ -25,18 +25,18 @@ func init() {
 type httpConnector struct {
 	user    *url.Userinfo
 	md      metadata
-	logger logger.Logger
+	options connector.Options
 }
 
 func NewConnector(opts ...connector.Option) connector.Connector {
-	options := &connector.Options{}
+	options := connector.Options{}
 	for _, opt := range opts {
-		opt(options)
+		opt(&options)
 	}
 
 	return &httpConnector{
 		user:    options.User,
-		logger: options.Logger,
+		options: options,
 	}
 }
 
@@ -45,13 +45,13 @@ func (c *httpConnector) Init(md md.Metadata) (err error) {
 }
 
 func (c *httpConnector) Connect(ctx context.Context, conn net.Conn, network, address string, opts ...connector.ConnectOption) (net.Conn, error) {
-	c.logger = c.logger.WithFields(map[string]interface{}{
+	log := c.options.Logger.WithFields(map[string]interface{}{
 		"local":   conn.LocalAddr().String(),
 		"remote":  conn.RemoteAddr().String(),
 		"network": network,
 		"address": address,
 	})
-	c.logger.Infof("connect %s/%s", address, network)
+	log.Infof("connect %s/%s", address, network)
 
 	req := &http.Request{
 		Method:     http.MethodConnect,
@@ -78,20 +78,20 @@ func (c *httpConnector) Connect(ctx context.Context, conn net.Conn, network, add
 	case "tcp", "tcp4", "tcp6":
 		if _, ok := conn.(net.PacketConn); ok {
 			err := fmt.Errorf("tcp over udp is unsupported")
-			c.logger.Error(err)
+			log.Error(err)
 			return nil, err
 		}
 	case "udp", "udp4", "udp6":
 		req.Header.Set("X-Gost-Protocol", "udp")
 	default:
 		err := fmt.Errorf("network %s is unsupported", network)
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
 
-	if c.logger.IsLevelEnabled(logger.DebugLevel) {
+	if log.IsLevelEnabled(logger.DebugLevel) {
 		dump, _ := httputil.DumpRequest(req, false)
-		c.logger.Debug(string(dump))
+		log.Debug(string(dump))
 	}
 
 	if c.md.connectTimeout > 0 {
@@ -110,9 +110,9 @@ func (c *httpConnector) Connect(ctx context.Context, conn net.Conn, network, add
 	}
 	defer resp.Body.Close()
 
-	if c.logger.IsLevelEnabled(logger.DebugLevel) {
+	if log.IsLevelEnabled(logger.DebugLevel) {
 		dump, _ := httputil.DumpResponse(resp, false)
-		c.logger.Debug(string(dump))
+		log.Debug(string(dump))
 	}
 
 	if resp.StatusCode != http.StatusOK {

pkg/connector/http2/connector.go

@@ -26,18 +26,18 @@ func init() {
 type http2Connector struct {
 	user    *url.Userinfo
 	md      metadata
-	logger logger.Logger
+	options connector.Options
 }
 
 func NewConnector(opts ...connector.Option) connector.Connector {
-	options := &connector.Options{}
+	options := connector.Options{}
 	for _, opt := range opts {
-		opt(options)
+		opt(&options)
 	}
 
 	return &http2Connector{
 		user:    options.User,
-		logger: options.Logger,
+		options: options,
 	}
 }
 
@@ -46,18 +46,18 @@ func (c *http2Connector) Init(md md.Metadata) (err error) {
 }
 
 func (c *http2Connector) Connect(ctx context.Context, conn net.Conn, network, address string, opts ...connector.ConnectOption) (net.Conn, error) {
-	c.logger = c.logger.WithFields(map[string]interface{}{
+	log := c.options.Logger.WithFields(map[string]interface{}{
 		"local":   conn.LocalAddr().String(),
 		"remote":  conn.RemoteAddr().String(),
 		"network": network,
 		"address": address,
 	})
-	c.logger.Infof("connect %s/%s", address, network)
+	log.Infof("connect %s/%s", address, network)
 
 	cc, ok := conn.(*http2_util.ClientConn)
 	if !ok {
 		err := errors.New("wrong connection type")
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
 
@@ -83,9 +83,9 @@ func (c *http2Connector) Connect(ctx context.Context, conn net.Conn, network, ad
 			"Basic "+base64.StdEncoding.EncodeToString([]byte(u+":"+p)))
 	}
 
-	if c.logger.IsLevelEnabled(logger.DebugLevel) {
+	if log.IsLevelEnabled(logger.DebugLevel) {
 		dump, _ := httputil.DumpRequest(req, false)
-		c.logger.Debug(string(dump))
+		log.Debug(string(dump))
 	}
 
 	if c.md.connectTimeout > 0 {
@@ -95,19 +95,19 @@ func (c *http2Connector) Connect(ctx context.Context, conn net.Conn, network, ad
 
 	resp, err := cc.Client().Do(req.WithContext(ctx))
 	if err != nil {
-		c.logger.Error(err)
+		log.Error(err)
 		cc.Close()
 		return nil, err
 	}
 
-	if c.logger.IsLevelEnabled(logger.DebugLevel) {
+	if log.IsLevelEnabled(logger.DebugLevel) {
 		dump, _ := httputil.DumpResponse(resp, false)
-		c.logger.Debug(string(dump))
+		log.Debug(string(dump))
 	}
 	if resp.StatusCode != http.StatusOK {
 		resp.Body.Close()
 		err = fmt.Errorf("%s", resp.Status)
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
 

pkg/connector/relay/bind.go

@@ -10,16 +10,17 @@ import (
 	"github.com/go-gost/gost/pkg/common/util/socks"
 	"github.com/go-gost/gost/pkg/common/util/udp"
 	"github.com/go-gost/gost/pkg/connector"
+	"github.com/go-gost/gost/pkg/logger"
 	"github.com/go-gost/relay"
 )
 
 // Bind implements connector.Binder.
 func (c *relayConnector) Bind(ctx context.Context, conn net.Conn, network, address string, opts ...connector.BindOption) (net.Listener, error) {
-	c.logger = c.logger.WithFields(map[string]interface{}{
+	log := c.options.Logger.WithFields(map[string]interface{}{
 		"network": network,
 		"address": address,
 	})
-	c.logger.Infof("bind on %s/%s", address, network)
+	log.Infof("bind on %s/%s", address, network)
 
 	options := connector.BindOptions{}
 	for _, opt := range opts {
@@ -28,21 +29,22 @@ func (c *relayConnector) Bind(ctx context.Context, conn net.Conn, network, addre
 
 	switch network {
 	case "tcp", "tcp4", "tcp6":
-		return c.bindTCP(ctx, conn, network, address)
+		return c.bindTCP(ctx, conn, network, address, log)
 	case "udp", "udp4", "udp6":
-		return c.bindUDP(ctx, conn, network, address, &options)
+		return c.bindUDP(ctx, conn, network, address, &options, log)
 	default:
 		err := fmt.Errorf("network %s is unsupported", network)
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
 }
 
-func (c *relayConnector) bindTCP(ctx context.Context, conn net.Conn, network, address string) (net.Listener, error) {
+func (c *relayConnector) bindTCP(ctx context.Context, conn net.Conn, network, address string, log logger.Logger) (net.Listener, error) {
 	laddr, err := c.bind(conn, relay.BIND, network, address)
 	if err != nil {
 		return nil, err
 	}
+	log.Debugf("bind on %s/%s OK", laddr, laddr.Network())
 
 	session, err := mux.ServerSession(conn)
 	if err != nil {
@@ -52,15 +54,16 @@ func (c *relayConnector) bindTCP(ctx context.Context, conn net.Conn, network, ad
 	return &tcpListener{
 		addr:    laddr,
 		session: session,
-		logger:  c.logger,
+		logger:  log,
 	}, nil
 }
 
-func (c *relayConnector) bindUDP(ctx context.Context, conn net.Conn, network, address string, opts *connector.BindOptions) (net.Listener, error) {
+func (c *relayConnector) bindUDP(ctx context.Context, conn net.Conn, network, address string, opts *connector.BindOptions, log logger.Logger) (net.Listener, error) {
 	laddr, err := c.bind(conn, relay.FUDP|relay.BIND, network, address)
 	if err != nil {
 		return nil, err
 	}
+	log.Debugf("bind on %s/%s OK", laddr, laddr.Network())
 
 	ln := udp.NewListener(
 		socks.UDPTunClientPacketConn(conn),
@@ -68,7 +71,7 @@ func (c *relayConnector) bindUDP(ctx context.Context, conn net.Conn, network, ad
 		opts.Backlog,
 		opts.UDPDataQueueSize, opts.UDPDataBufferSize,
 		opts.UDPConnTTL,
-		c.logger)
+		log)
 
 	return ln, nil
 }
@@ -125,7 +128,6 @@ func (c *relayConnector) bind(conn net.Conn, cmd uint8, network, address string)
 	if err != nil {
 		return nil, err
 	}
-	c.logger.Debugf("bind on %s/%s OK", baddr, baddr.Network())
 
 	return baddr, nil
 }

pkg/connector/relay/connector.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/go-gost/gost/pkg/common/util/socks"
 	"github.com/go-gost/gost/pkg/connector"
-	"github.com/go-gost/gost/pkg/logger"
 	md "github.com/go-gost/gost/pkg/metadata"
 	"github.com/go-gost/gost/pkg/registry"
 	"github.com/go-gost/relay"
@@ -21,19 +20,19 @@ func init() {
 
 type relayConnector struct {
 	user    *url.Userinfo
-	logger logger.Logger
 	md      metadata
+	options connector.Options
 }
 
 func NewConnector(opts ...connector.Option) connector.Connector {
-	options := &connector.Options{}
+	options := connector.Options{}
 	for _, opt := range opts {
-		opt(options)
+		opt(&options)
 	}
 
 	return &relayConnector{
 		user:    options.User,
-		logger: options.Logger,
+		options: options,
 	}
 }
 
@@ -42,13 +41,13 @@ func (c *relayConnector) Init(md md.Metadata) (err error) {
 }
 
 func (c *relayConnector) Connect(ctx context.Context, conn net.Conn, network, address string, opts ...connector.ConnectOption) (net.Conn, error) {
-	c.logger = c.logger.WithFields(map[string]interface{}{
+	log := c.options.Logger.WithFields(map[string]interface{}{
 		"remote":  conn.RemoteAddr().String(),
 		"local":   conn.LocalAddr().String(),
 		"network": network,
 		"address": address,
 	})
-	c.logger.Infof("connect %s/%s", address, network)
+	log.Infof("connect %s/%s", address, network)
 
 	if c.md.connectTimeout > 0 {
 		conn.SetDeadline(time.Now().Add(c.md.connectTimeout))
@@ -68,7 +67,7 @@ func (c *relayConnector) Connect(ctx context.Context, conn net.Conn, network, ad
 			if err != nil {
 				return nil, err
 			}
-			c.logger.Debugf("associate on %s OK", baddr)
+			log.Debugf("associate on %s OK", baddr)
 
 			return socks.UDPTunClientConn(conn, nil), nil
 		}
@@ -123,7 +122,7 @@ func (c *relayConnector) Connect(ctx context.Context, conn net.Conn, network, ad
 		conn = cc
 	default:
 		err := fmt.Errorf("network %s is unsupported", network)
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
 

pkg/connector/sni/connector.go

@@ -5,7 +5,6 @@ import (
 	"net"
 
 	"github.com/go-gost/gost/pkg/connector"
-	"github.com/go-gost/gost/pkg/logger"
 	md "github.com/go-gost/gost/pkg/metadata"
 	"github.com/go-gost/gost/pkg/registry"
 )
@@ -16,17 +15,17 @@ func init() {
 
 type sniConnector struct {
 	md      metadata
-	logger logger.Logger
+	options connector.Options
 }
 
 func NewConnector(opts ...connector.Option) connector.Connector {
-	options := &connector.Options{}
+	options := connector.Options{}
 	for _, opt := range opts {
-		opt(options)
+		opt(&options)
 	}
 
 	return &sniConnector{
-		logger: options.Logger,
+		options: options,
 	}
 }
 
@@ -35,13 +34,13 @@ func (c *sniConnector) Init(md md.Metadata) (err error) {
 }
 
 func (c *sniConnector) Connect(ctx context.Context, conn net.Conn, network, address string, opts ...connector.ConnectOption) (net.Conn, error) {
-	c.logger = c.logger.WithFields(map[string]interface{}{
+	log := c.options.Logger.WithFields(map[string]interface{}{
 		"remote":  conn.RemoteAddr().String(),
 		"local":   conn.LocalAddr().String(),
 		"network": network,
 		"address": address,
 	})
-	c.logger.Infof("connect %s/%s", address, network)
+	log.Infof("connect %s/%s", address, network)
 
 	return &sniClientConn{Conn: conn, host: c.md.host}, nil
 }

pkg/connector/socks/v4/connector.go

@@ -11,7 +11,6 @@ import (
 
 	"github.com/go-gost/gosocks4"
 	"github.com/go-gost/gost/pkg/connector"
-	"github.com/go-gost/gost/pkg/logger"
 	md "github.com/go-gost/gost/pkg/metadata"
 	"github.com/go-gost/gost/pkg/registry"
 )
@@ -24,18 +23,18 @@ func init() {
 type socks4Connector struct {
 	user    *url.Userinfo
 	md      metadata
-	logger logger.Logger
+	options connector.Options
 }
 
 func NewConnector(opts ...connector.Option) connector.Connector {
-	options := &connector.Options{}
+	options := connector.Options{}
 	for _, opt := range opts {
-		opt(options)
+		opt(&options)
 	}
 
 	return &socks4Connector{
 		user:    options.User,
-		logger: options.Logger,
+		options: options,
 	}
 }
 
@@ -44,24 +43,24 @@ func (c *socks4Connector) Init(md md.Metadata) (err error) {
 }
 
 func (c *socks4Connector) Connect(ctx context.Context, conn net.Conn, network, address string, opts ...connector.ConnectOption) (net.Conn, error) {
-	c.logger = c.logger.WithFields(map[string]interface{}{
+	log := c.options.Logger.WithFields(map[string]interface{}{
 		"remote":  conn.RemoteAddr().String(),
 		"local":   conn.LocalAddr().String(),
 		"network": network,
 		"address": address,
 	})
-	c.logger.Infof("connect %s/%s", address, network)
+	log.Infof("connect %s/%s", address, network)
 
 	switch network {
 	case "tcp", "tcp4", "tcp6":
 		if _, ok := conn.(net.PacketConn); ok {
 			err := fmt.Errorf("tcp over udp is unsupported")
-			c.logger.Error(err)
+			log.Error(err)
 			return nil, err
 		}
 	default:
 		err := fmt.Errorf("network %s is unsupported", network)
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
 
@@ -70,7 +69,7 @@ func (c *socks4Connector) Connect(ctx context.Context, conn net.Conn, network, a
 	if c.md.disable4a {
 		taddr, err := net.ResolveTCPAddr("tcp4", address)
 		if err != nil {
-			c.logger.Error("resolve: ", err)
+			log.Error("resolve: ", err)
 			return nil, err
 		}
 		if len(taddr.IP) == 0 {
@@ -105,21 +104,21 @@ func (c *socks4Connector) Connect(ctx context.Context, conn net.Conn, network, a
 	}
 	req := gosocks4.NewRequest(gosocks4.CmdConnect, addr, userid)
 	if err := req.Write(conn); err != nil {
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
-	c.logger.Debug(req)
+	log.Debug(req)
 
 	reply, err := gosocks4.ReadReply(conn)
 	if err != nil {
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
-	c.logger.Debug(reply)
+	log.Debug(reply)
 
 	if reply.Code != gosocks4.Granted {
 		err = errors.New("host unreachable")
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
 

pkg/connector/socks/v5/bind.go

@@ -10,15 +10,18 @@ import (
 	"github.com/go-gost/gost/pkg/common/util/socks"
 	"github.com/go-gost/gost/pkg/common/util/udp"
 	"github.com/go-gost/gost/pkg/connector"
+	"github.com/go-gost/gost/pkg/logger"
 )
 
 // Bind implements connector.Binder.
 func (c *socks5Connector) Bind(ctx context.Context, conn net.Conn, network, address string, opts ...connector.BindOption) (net.Listener, error) {
-	c.logger = c.logger.WithFields(map[string]interface{}{
+	log := c.options.Logger.WithFields(map[string]interface{}{
+		"remote":  conn.RemoteAddr().String(),
+		"local":   conn.LocalAddr().String(),
 		"network": network,
 		"address": address,
 	})
-	c.logger.Infof("bind: %s/%s", address, network)
+	log.Infof("bind: %s/%s", address, network)
 
 	options := connector.BindOptions{}
 	for _, opt := range opts {
@@ -28,20 +31,20 @@ func (c *socks5Connector) Bind(ctx context.Context, conn net.Conn, network, addr
 	switch network {
 	case "tcp", "tcp4", "tcp6":
 		if options.Mux {
-			return c.muxBindTCP(ctx, conn, network, address)
+			return c.muxBindTCP(ctx, conn, network, address, log)
 		}
-		return c.bindTCP(ctx, conn, network, address)
+		return c.bindTCP(ctx, conn, network, address, log)
 	case "udp", "udp4", "udp6":
-		return c.bindUDP(ctx, conn, network, address, &options)
+		return c.bindUDP(ctx, conn, network, address, &options, log)
 	default:
 		err := fmt.Errorf("network %s is unsupported", network)
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
 }
 
-func (c *socks5Connector) bindTCP(ctx context.Context, conn net.Conn, network, address string) (net.Listener, error) {
+func (c *socks5Connector) bindTCP(ctx context.Context, conn net.Conn, network, address string, log logger.Logger) (net.Listener, error) {
-	laddr, err := c.bind(conn, gosocks5.CmdBind, network, address)
+	laddr, err := c.bind(conn, gosocks5.CmdBind, network, address, log)
 	if err != nil {
 		return nil, err
 	}
@@ -49,12 +52,12 @@ func (c *socks5Connector) bindTCP(ctx context.Context, conn net.Conn, network, a
 	return &tcpListener{
 		addr:   laddr,
 		conn:   conn,
-		logger: c.logger,
+		logger: log,
 	}, nil
 }
 
-func (c *socks5Connector) muxBindTCP(ctx context.Context, conn net.Conn, network, address string) (net.Listener, error) {
+func (c *socks5Connector) muxBindTCP(ctx context.Context, conn net.Conn, network, address string, log logger.Logger) (net.Listener, error) {
-	laddr, err := c.bind(conn, socks.CmdMuxBind, network, address)
+	laddr, err := c.bind(conn, socks.CmdMuxBind, network, address, log)
 	if err != nil {
 		return nil, err
 	}
@@ -67,12 +70,12 @@ func (c *socks5Connector) muxBindTCP(ctx context.Context, conn net.Conn, network
 	return &tcpMuxListener{
 		addr:    laddr,
 		session: session,
-		logger:  c.logger,
+		logger:  log,
 	}, nil
 }
 
-func (c *socks5Connector) bindUDP(ctx context.Context, conn net.Conn, network, address string, opts *connector.BindOptions) (net.Listener, error) {
+func (c *socks5Connector) bindUDP(ctx context.Context, conn net.Conn, network, address string, opts *connector.BindOptions, log logger.Logger) (net.Listener, error) {
-	laddr, err := c.bind(conn, socks.CmdUDPTun, network, address)
+	laddr, err := c.bind(conn, socks.CmdUDPTun, network, address, log)
 	if err != nil {
 		return nil, err
 	}
@@ -83,19 +86,19 @@ func (c *socks5Connector) bindUDP(ctx context.Context, conn net.Conn, network, a
 		opts.Backlog,
 		opts.UDPDataQueueSize, opts.UDPDataBufferSize,
 		opts.UDPConnTTL,
-		c.logger)
+		log)
 
 	return ln, nil
 }
 
-func (l *socks5Connector) bind(conn net.Conn, cmd uint8, network, address string) (net.Addr, error) {
+func (l *socks5Connector) bind(conn net.Conn, cmd uint8, network, address string, log logger.Logger) (net.Addr, error) {
 	addr := gosocks5.Addr{}
 	addr.ParseFrom(address)
 	req := gosocks5.NewRequest(cmd, &addr)
 	if err := req.Write(conn); err != nil {
 		return nil, err
 	}
-	l.logger.Debug(req)
+	log.Debug(req)
 
 	// first reply, bind status
 	reply, err := gosocks5.ReadReply(conn)
@@ -103,7 +106,7 @@ func (l *socks5Connector) bind(conn net.Conn, cmd uint8, network, address string
 		return nil, err
 	}
 
-	l.logger.Debug(reply)
+	log.Debug(reply)
 
 	if reply.Rep != gosocks5.Succeeded {
 		return nil, fmt.Errorf("bind on %s/%s failed", address, network)
@@ -121,7 +124,7 @@ func (l *socks5Connector) bind(conn net.Conn, cmd uint8, network, address string
 	if err != nil {
 		return nil, err
 	}
-	l.logger.Debugf("bind on %s/%s OK", baddr, baddr.Network())
+	log.Debugf("bind on %s/%s OK", baddr, baddr.Network())
 
 	return baddr, nil
 }

pkg/connector/socks/v5/connector.go

@@ -23,7 +23,6 @@ func init() {
 
 type socks5Connector struct {
 	selector gosocks5.Selector
-	logger   logger.Logger
 	md       metadata
 	options  connector.Options
 }
@@ -44,16 +43,14 @@ func (c *socks5Connector) Init(md md.Metadata) (err error) {
 		return
 	}
 
-	c.logger = c.options.Logger
-
 	selector := &clientSelector{
 		methods: []uint8{
 			gosocks5.MethodNoAuth,
 			gosocks5.MethodUserPass,
 		},
-		logger:    c.logger,
 		User:      c.options.User,
 		TLSConfig: c.options.TLSConfig,
+		logger:    c.options.Logger,
 	}
 	if !c.md.noTLS {
 		selector.methods = append(selector.methods, socks.MethodTLS)
@@ -70,7 +67,7 @@ func (c *socks5Connector) Init(md md.Metadata) (err error) {
 
 // Handshake implements connector.Handshaker.
 func (c *socks5Connector) Handshake(ctx context.Context, conn net.Conn) (net.Conn, error) {
-	c.logger = c.logger.WithFields(map[string]interface{}{
+	log := c.options.Logger.WithFields(map[string]interface{}{
 		"remote": conn.RemoteAddr().String(),
 		"local":  conn.LocalAddr().String(),
 	})
@@ -82,7 +79,7 @@ func (c *socks5Connector) Handshake(ctx context.Context, conn net.Conn) (net.Con
 
 	cc := gosocks5.ClientConn(conn, c.selector)
 	if err := cc.Handleshake(); err != nil {
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
 
@@ -90,11 +87,13 @@ func (c *socks5Connector) Handshake(ctx context.Context, conn net.Conn) (net.Con
 }
 
 func (c *socks5Connector) Connect(ctx context.Context, conn net.Conn, network, address string, opts ...connector.ConnectOption) (net.Conn, error) {
-	c.logger = c.logger.WithFields(map[string]interface{}{
+	log := c.options.Logger.WithFields(map[string]interface{}{
+		"remote":  conn.RemoteAddr().String(),
+		"local":   conn.LocalAddr().String(),
 		"network": network,
 		"address": address,
 	})
-	c.logger.Infof("connect %s/%s", address, network)
+	log.Infof("connect %s/%s", address, network)
 
 	if c.md.connectTimeout > 0 {
 		conn.SetDeadline(time.Now().Add(c.md.connectTimeout))
@@ -103,68 +102,68 @@ func (c *socks5Connector) Connect(ctx context.Context, conn net.Conn, network, a
 
 	switch network {
 	case "udp", "udp4", "udp6":
-		return c.connectUDP(ctx, conn, network, address)
+		return c.connectUDP(ctx, conn, network, address, log)
 	case "tcp", "tcp4", "tcp6":
 		if _, ok := conn.(net.PacketConn); ok {
 			err := fmt.Errorf("tcp over udp is unsupported")
-			c.logger.Error(err)
+			log.Error(err)
 			return nil, err
 		}
 	default:
 		err := fmt.Errorf("network %s is unsupported", network)
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
 
 	addr := gosocks5.Addr{}
 	if err := addr.ParseFrom(address); err != nil {
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
 
 	req := gosocks5.NewRequest(gosocks5.CmdConnect, &addr)
 	if err := req.Write(conn); err != nil {
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
-	c.logger.Debug(req)
+	log.Debug(req)
 
 	reply, err := gosocks5.ReadReply(conn)
 	if err != nil {
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
-	c.logger.Debug(reply)
+	log.Debug(reply)
 
 	if reply.Rep != gosocks5.Succeeded {
 		err = errors.New("host unreachable")
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
 
 	return conn, nil
 }
 
-func (c *socks5Connector) connectUDP(ctx context.Context, conn net.Conn, network, address string) (net.Conn, error) {
+func (c *socks5Connector) connectUDP(ctx context.Context, conn net.Conn, network, address string, log logger.Logger) (net.Conn, error) {
 	addr, err := net.ResolveUDPAddr(network, address)
 	if err != nil {
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
 
 	req := gosocks5.NewRequest(socks.CmdUDPTun, nil)
 	if err := req.Write(conn); err != nil {
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
-	c.logger.Debug(req)
+	log.Debug(req)
 
 	reply, err := gosocks5.ReadReply(conn)
 	if err != nil {
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
-	c.logger.Debug(reply)
+	log.Debug(reply)
 
 	if reply.Rep != gosocks5.Succeeded {
 		return nil, errors.New("get socks5 UDP tunnel failure")

pkg/connector/ss/connector.go

@@ -10,7 +10,6 @@ import (
 	"github.com/go-gost/gost/pkg/common/bufpool"
 	"github.com/go-gost/gost/pkg/common/util/ss"
 	"github.com/go-gost/gost/pkg/connector"
-	"github.com/go-gost/gost/pkg/logger"
 	md "github.com/go-gost/gost/pkg/metadata"
 	"github.com/go-gost/gost/pkg/registry"
 	"github.com/shadowsocks/go-shadowsocks2/core"
@@ -23,7 +22,6 @@ func init() {
 type ssConnector struct {
 	cipher  core.Cipher
 	md      metadata
-	logger  logger.Logger
 	options connector.Options
 }
 
@@ -35,7 +33,6 @@ func NewConnector(opts ...connector.Option) connector.Connector {
 
 	return &ssConnector{
 		options: options,
-		logger:  options.Logger,
 	}
 }
 
@@ -54,30 +51,30 @@ func (c *ssConnector) Init(md md.Metadata) (err error) {
 }
 
 func (c *ssConnector) Connect(ctx context.Context, conn net.Conn, network, address string, opts ...connector.ConnectOption) (net.Conn, error) {
-	c.logger = c.logger.WithFields(map[string]interface{}{
+	log := c.options.Logger.WithFields(map[string]interface{}{
 		"remote":  conn.RemoteAddr().String(),
 		"local":   conn.LocalAddr().String(),
 		"network": network,
 		"address": address,
 	})
-	c.logger.Infof("connect %s/%s", address, network)
+	log.Infof("connect %s/%s", address, network)
 
 	switch network {
 	case "tcp", "tcp4", "tcp6":
 		if _, ok := conn.(net.PacketConn); ok {
 			err := fmt.Errorf("tcp over udp is unsupported")
-			c.logger.Error(err)
+			log.Error(err)
 			return nil, err
 		}
 	default:
 		err := fmt.Errorf("network %s is unsupported", network)
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
 
 	addr := gosocks5.Addr{}
 	if err := addr.ParseFrom(address); err != nil {
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
 	rawaddr := bufpool.Get(512)
@@ -85,7 +82,7 @@ func (c *ssConnector) Connect(ctx context.Context, conn net.Conn, network, addre
 
 	n, err := addr.Encode(*rawaddr)
 	if err != nil {
-		c.logger.Error("encoding addr: ", err)
+		log.Error("encoding addr: ", err)
 		return nil, err
 	}
 

pkg/connector/ss/udp/connector.go

@@ -9,7 +9,6 @@ import (
 	"github.com/go-gost/gost/pkg/common/util/socks"
 	"github.com/go-gost/gost/pkg/common/util/ss"
 	"github.com/go-gost/gost/pkg/connector"
-	"github.com/go-gost/gost/pkg/logger"
 	md "github.com/go-gost/gost/pkg/metadata"
 	"github.com/go-gost/gost/pkg/registry"
 	"github.com/shadowsocks/go-shadowsocks2/core"
@@ -22,7 +21,6 @@ func init() {
 type ssuConnector struct {
 	cipher  core.Cipher
 	md      metadata
-	logger  logger.Logger
 	options connector.Options
 }
 
@@ -34,7 +32,6 @@ func NewConnector(opts ...connector.Option) connector.Connector {
 
 	return &ssuConnector{
 		options: options,
-		logger:  options.Logger,
 	}
 }
 
@@ -53,19 +50,19 @@ func (c *ssuConnector) Init(md md.Metadata) (err error) {
 }
 
 func (c *ssuConnector) Connect(ctx context.Context, conn net.Conn, network, address string, opts ...connector.ConnectOption) (net.Conn, error) {
-	c.logger = c.logger.WithFields(map[string]interface{}{
+	log := c.options.Logger.WithFields(map[string]interface{}{
 		"remote":  conn.RemoteAddr().String(),
 		"local":   conn.LocalAddr().String(),
 		"network": network,
 		"address": address,
 	})
-	c.logger.Infof("connect %s/%s", address, network)
+	log.Infof("connect %s/%s", address, network)
 
 	switch network {
 	case "udp", "udp4", "udp6":
 	default:
 		err := fmt.Errorf("network %s is unsupported", network)
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
 

pkg/connector/sshd/connector.go

@@ -1,4 +1,4 @@
-package ssh
+package sshd
 
 import (
 	"context"
@@ -7,7 +7,6 @@ import (
 
 	"github.com/go-gost/gost/pkg/connector"
 	ssh_util "github.com/go-gost/gost/pkg/internal/util/ssh"
-	"github.com/go-gost/gost/pkg/logger"
 	md "github.com/go-gost/gost/pkg/metadata"
 	"github.com/go-gost/gost/pkg/registry"
 )
@@ -16,33 +15,33 @@ func init() {
 	registry.RegiserConnector("sshd", NewConnector)
 }
 
-type forwardConnector struct {
+type sshdConnector struct {
-	logger logger.Logger
+	options connector.Options
 }
 
 func NewConnector(opts ...connector.Option) connector.Connector {
-	options := &connector.Options{}
+	options := connector.Options{}
 	for _, opt := range opts {
-		opt(options)
+		opt(&options)
 	}
 
-	return &forwardConnector{
+	return &sshdConnector{
-		logger: options.Logger,
+		options: options,
 	}
 }
 
-func (c *forwardConnector) Init(md md.Metadata) (err error) {
+func (c *sshdConnector) Init(md md.Metadata) (err error) {
 	return nil
 }
 
-func (c *forwardConnector) Connect(ctx context.Context, conn net.Conn, network, address string, opts ...connector.ConnectOption) (net.Conn, error) {
+func (c *sshdConnector) Connect(ctx context.Context, conn net.Conn, network, address string, opts ...connector.ConnectOption) (net.Conn, error) {
-	c.logger = c.logger.WithFields(map[string]interface{}{
+	log := c.options.Logger.WithFields(map[string]interface{}{
 		"remote":  conn.RemoteAddr().String(),
 		"local":   conn.LocalAddr().String(),
 		"network": network,
 		"address": address,
 	})
-	c.logger.Infof("connect %s/%s", address, network)
+	log.Infof("connect %s/%s", address, network)
 
 	cc, ok := conn.(*ssh_util.ClientConn)
 	if !ok {
@@ -51,7 +50,7 @@ func (c *forwardConnector) Connect(ctx context.Context, conn net.Conn, network,
 
 	conn, err := cc.Client().Dial(network, address)
 	if err != nil {
-		c.logger.Error(err)
+		log.Error(err)
 		return nil, err
 	}
 
@@ -59,12 +58,14 @@ func (c *forwardConnector) Connect(ctx context.Context, conn net.Conn, network,
 }
 
 // Bind implements connector.Binder.
-func (c *forwardConnector) Bind(ctx context.Context, conn net.Conn, network, address string, opts ...connector.BindOption) (net.Listener, error) {
+func (c *sshdConnector) Bind(ctx context.Context, conn net.Conn, network, address string, opts ...connector.BindOption) (net.Listener, error) {
-	c.logger = c.logger.WithFields(map[string]interface{}{
+	log := c.options.Logger.WithFields(map[string]interface{}{
+		"remote":  conn.RemoteAddr().String(),
+		"local":   conn.LocalAddr().String(),
 		"network": network,
 		"address": address,
 	})
-	c.logger.Infof("bind on %s/%s", address, network)
+	log.Infof("bind on %s/%s", address, network)
 
 	cc, ok := conn.(*ssh_util.ClientConn)
 	if !ok {

pkg/dialer/sshd/conn.go

@@ -1,4 +1,4 @@
-package ssh
+package sshd
 
 import (
 	"net"

pkg/dialer/sshd/dialer.go

@@ -1,4 +1,4 @@
-package ssh
+package sshd
 
 import (
 	"context"
@@ -10,7 +10,6 @@ import (
 
 	"github.com/go-gost/gost/pkg/dialer"
 	ssh_util "github.com/go-gost/gost/pkg/internal/util/ssh"
-	"github.com/go-gost/gost/pkg/logger"
 	md "github.com/go-gost/gost/pkg/metadata"
 	"github.com/go-gost/gost/pkg/registry"
 	"golang.org/x/crypto/ssh"
@@ -20,28 +19,28 @@ func init() {
 	registry.RegisterDialer("sshd", NewDialer)
 }
 
-type forwardDialer struct {
+type sshdDialer struct {
 	user         *url.Userinfo
 	sessions     map[string]*sshSession
 	sessionMutex sync.Mutex
-	logger       logger.Logger
 	md           metadata
+	options      dialer.Options
 }
 
 func NewDialer(opts ...dialer.Option) dialer.Dialer {
-	options := &dialer.Options{}
+	options := dialer.Options{}
 	for _, opt := range opts {
-		opt(options)
+		opt(&options)
 	}
 
-	return &forwardDialer{
+	return &sshdDialer{
 		user:     options.User,
 		sessions: make(map[string]*sshSession),
-		logger:   options.Logger,
+		options:  options,
 	}
 }
 
-func (d *forwardDialer) Init(md md.Metadata) (err error) {
+func (d *sshdDialer) Init(md md.Metadata) (err error) {
 	if err = d.parseMetadata(md); err != nil {
 		return
 	}
@@ -50,11 +49,11 @@ func (d *forwardDialer) Init(md md.Metadata) (err error) {
 }
 
 // Multiplex implements dialer.Multiplexer interface.
-func (d *forwardDialer) Multiplex() bool {
+func (d *sshdDialer) Multiplex() bool {
 	return true
 }
 
-func (d *forwardDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOption) (conn net.Conn, err error) {
+func (d *sshdDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOption) (conn net.Conn, err error) {
 	var options dialer.DialOptions
 	for _, opt := range opts {
 		opt(&options)
@@ -85,7 +84,7 @@ func (d *forwardDialer) Dial(ctx context.Context, addr string, opts ...dialer.Di
 }
 
 // Handshake implements dialer.Handshaker
-func (d *forwardDialer) Handshake(ctx context.Context, conn net.Conn, options ...dialer.HandshakeOption) (net.Conn, error) {
+func (d *sshdDialer) Handshake(ctx context.Context, conn net.Conn, options ...dialer.HandshakeOption) (net.Conn, error) {
 	opts := &dialer.HandshakeOptions{}
 	for _, option := range options {
 		option(opts)
@@ -99,10 +98,12 @@ func (d *forwardDialer) Handshake(ctx context.Context, conn net.Conn, options ..
 		defer conn.SetDeadline(time.Time{})
 	}
 
+	log := d.options.Logger
+
 	session, ok := d.sessions[opts.Addr]
 	if session != nil && session.conn != conn {
 		err := errors.New("ssh: unrecognized connection")
-		d.logger.Error(err)
+		log.Error(err)
 		conn.Close()
 		delete(d.sessions, opts.Addr)
 		return nil, err
@@ -111,7 +112,7 @@ func (d *forwardDialer) Handshake(ctx context.Context, conn net.Conn, options ..
 	if !ok || session.client == nil {
 		s, err := d.initSession(ctx, opts.Addr, conn)
 		if err != nil {
-			d.logger.Error(err)
+			log.Error(err)
 			conn.Close()
 			delete(d.sessions, opts.Addr)
 			return nil, err
@@ -119,7 +120,7 @@ func (d *forwardDialer) Handshake(ctx context.Context, conn net.Conn, options ..
 		session = s
 		go func() {
 			s.wait()
-			d.logger.Debug("session closed")
+			log.Debug("session closed")
 		}()
 		d.sessions[opts.Addr] = session
 	}
@@ -131,14 +132,16 @@ func (d *forwardDialer) Handshake(ctx context.Context, conn net.Conn, options ..
 	return ssh_util.NewClientConn(session.conn, session.client), nil
 }
 
-func (d *forwardDialer) dial(ctx context.Context, network, addr string, opts *dialer.DialOptions) (net.Conn, error) {
+func (d *sshdDialer) dial(ctx context.Context, network, addr string, opts *dialer.DialOptions) (net.Conn, error) {
+	log := d.options.Logger
+
 	dial := opts.DialFunc
 	if dial != nil {
 		conn, err := dial(ctx, addr)
 		if err != nil {
-			d.logger.Error(err)
+			log.Error(err)
 		} else {
-			d.logger.WithFields(map[string]interface{}{
+			log.WithFields(map[string]interface{}{
 				"src": conn.LocalAddr().String(),
 				"dst": addr,
 			}).Debug("dial with dial func")
@@ -149,9 +152,9 @@ func (d *forwardDialer) dial(ctx context.Context, network, addr string, opts *di
 	var netd net.Dialer
 	conn, err := netd.DialContext(ctx, network, addr)
 	if err != nil {
-		d.logger.Error(err)
+		log.Error(err)
 	} else {
-		d.logger.WithFields(map[string]interface{}{
+		log.WithFields(map[string]interface{}{
 			"src": conn.LocalAddr().String(),
 			"dst": addr,
 		}).Debugf("dial direct %s/%s", addr, network)
@@ -159,7 +162,7 @@ func (d *forwardDialer) dial(ctx context.Context, network, addr string, opts *di
 	return conn, err
 }
 
-func (d *forwardDialer) initSession(ctx context.Context, addr string, conn net.Conn) (*sshSession, error) {
+func (d *sshdDialer) initSession(ctx context.Context, addr string, conn net.Conn) (*sshSession, error) {
 	config := ssh.ClientConfig{
 		// Timeout:         timeout,
 		HostKeyCallback: ssh.InsecureIgnoreHostKey(),

pkg/dialer/sshd/metadata.go

@@ -1,4 +1,4 @@
-package ssh
+package sshd
 
 import (
 	"io/ioutil"
@@ -13,7 +13,7 @@ type metadata struct {
 	signer           ssh.Signer
 }
 
-func (d *forwardDialer) parseMetadata(md mdata.Metadata) (err error) {
+func (d *sshdDialer) parseMetadata(md mdata.Metadata) (err error) {
 	const (
 		handshakeTimeout = "handshakeTimeout"
 		privateKeyFile   = "privateKeyFile"