add sshd listener

pkg/handler/socks/v4/handler.go

@@ -23,7 +23,6 @@ func init() {
 type socks4Handler struct {
 	router        *chain.Router
 	authenticator auth.Authenticator
-	logger        logger.Logger
 	md            metadata
 	options       handler.Options
 }
@@ -52,7 +51,6 @@ func (h *socks4Handler) Init(md md.Metadata) (err error) {
 		Hosts:    h.options.Hosts,
 		Logger:   h.options.Logger,
 	}
-	h.logger = h.options.Logger
 
 	return nil
 }
@@ -62,14 +60,14 @@ func (h *socks4Handler) Handle(ctx context.Context, conn net.Conn) {
 
 	start := time.Now()
 
-	h.logger = h.logger.WithFields(map[string]interface{}{
+	log := h.options.Logger.WithFields(map[string]interface{}{
 		"remote": conn.RemoteAddr().String(),
 		"local":  conn.LocalAddr().String(),
 	})
 
-	h.logger.Infof("%s <> %s", conn.RemoteAddr(), conn.LocalAddr())
+	log.Infof("%s <> %s", conn.RemoteAddr(), conn.LocalAddr())
 	defer func() {
-		h.logger.WithFields(map[string]interface{}{
+		log.WithFields(map[string]interface{}{
 			"duration": time.Since(start),
 		}).Infof("%s >< %s", conn.RemoteAddr(), conn.LocalAddr())
 	}()
@@ -80,10 +78,10 @@ func (h *socks4Handler) Handle(ctx context.Context, conn net.Conn) {
 
 	req, err := gosocks4.ReadRequest(conn)
 	if err != nil {
-		h.logger.Error(err)
+		log.Error(err)
 		return
 	}
-	h.logger.Debug(req)
+	log.Debug(req)
 
 	conn.SetReadDeadline(time.Time{})
 
@@ -91,33 +89,33 @@ func (h *socks4Handler) Handle(ctx context.Context, conn net.Conn) {
 		!h.authenticator.Authenticate(string(req.Userid), "") {
 		resp := gosocks4.NewReply(gosocks4.RejectedUserid, nil)
 		resp.Write(conn)
-		h.logger.Debug(resp)
+		log.Debug(resp)
 		return
 	}
 
 	switch req.Cmd {
 	case gosocks4.CmdConnect:
-		h.handleConnect(ctx, conn, req)
+		h.handleConnect(ctx, conn, req, log)
 	case gosocks4.CmdBind:
 		h.handleBind(ctx, conn, req)
 	default:
-		h.logger.Errorf("unknown cmd: %d", req.Cmd)
+		log.Errorf("unknown cmd: %d", req.Cmd)
 	}
 }
 
-func (h *socks4Handler) handleConnect(ctx context.Context, conn net.Conn, req *gosocks4.Request) {
+func (h *socks4Handler) handleConnect(ctx context.Context, conn net.Conn, req *gosocks4.Request, log logger.Logger) {
 	addr := req.Addr.String()
 
-	h.logger = h.logger.WithFields(map[string]interface{}{
+	log = log.WithFields(map[string]interface{}{
 		"dst": addr,
 	})
-	h.logger.Infof("%s >> %s", conn.RemoteAddr(), addr)
+	log.Infof("%s >> %s", conn.RemoteAddr(), addr)
 
 	if h.options.Bypass != nil && h.options.Bypass.Contains(addr) {
 		resp := gosocks4.NewReply(gosocks4.Rejected, nil)
 		resp.Write(conn)
-		h.logger.Debug(resp)
-		h.logger.Info("bypass: ", addr)
+		log.Debug(resp)
+		log.Info("bypass: ", addr)
 		return
 	}
 
@@ -125,7 +123,7 @@ func (h *socks4Handler) handleConnect(ctx context.Context, conn net.Conn, req *g
 	if err != nil {
 		resp := gosocks4.NewReply(gosocks4.Failed, nil)
 		resp.Write(conn)
-		h.logger.Debug(resp)
+		log.Debug(resp)
 		return
 	}
 
@@ -133,19 +131,17 @@ func (h *socks4Handler) handleConnect(ctx context.Context, conn net.Conn, req *g
 
 	resp := gosocks4.NewReply(gosocks4.Granted, nil)
 	if err := resp.Write(conn); err != nil {
-		h.logger.Error(err)
+		log.Error(err)
 		return
 	}
-	h.logger.Debug(resp)
+	log.Debug(resp)
 
 	t := time.Now()
-	h.logger.Infof("%s <-> %s", conn.RemoteAddr(), addr)
+	log.Infof("%s <-> %s", conn.RemoteAddr(), addr)
 	handler.Transport(conn, cc)
-	h.logger.
-		WithFields(map[string]interface{}{
-			"duration": time.Since(t),
-		}).
-		Infof("%s >-< %s", conn.RemoteAddr(), addr)
+	log.WithFields(map[string]interface{}{
+		"duration": time.Since(t),
+	}).Infof("%s >-< %s", conn.RemoteAddr(), addr)
 }
 
 func (h *socks4Handler) handleBind(ctx context.Context, conn net.Conn, req *gosocks4.Request) {

pkg/handler/socks/v5/bind.go

@@ -8,43 +8,44 @@ import (
 
 	"github.com/go-gost/gosocks5"
 	"github.com/go-gost/gost/pkg/handler"
+	"github.com/go-gost/gost/pkg/logger"
 )
 
-func (h *socks5Handler) handleBind(ctx context.Context, conn net.Conn, network, address string) {
-	h.logger = h.logger.WithFields(map[string]interface{}{
+func (h *socks5Handler) handleBind(ctx context.Context, conn net.Conn, network, address string, log logger.Logger) {
+	log = log.WithFields(map[string]interface{}{
 		"dst": fmt.Sprintf("%s/%s", address, network),
 		"cmd": "bind",
 	})
 
-	h.logger.Infof("%s >> %s", conn.RemoteAddr(), address)
+	log.Infof("%s >> %s", conn.RemoteAddr(), address)
 
 	if !h.md.enableBind {
 		reply := gosocks5.NewReply(gosocks5.NotAllowed, nil)
 		reply.Write(conn)
-		h.logger.Debug(reply)
-		h.logger.Error("BIND is diabled")
+		log.Debug(reply)
+		log.Error("BIND is diabled")
 		return
 	}
 
 	// BIND does not support chain.
-	h.bindLocal(ctx, conn, network, address)
+	h.bindLocal(ctx, conn, network, address, log)
 }
 
-func (h *socks5Handler) bindLocal(ctx context.Context, conn net.Conn, network, address string) {
+func (h *socks5Handler) bindLocal(ctx context.Context, conn net.Conn, network, address string, log logger.Logger) {
 	ln, err := net.Listen(network, address) // strict mode: if the port already in use, it will return error
 	if err != nil {
-		h.logger.Error(err)
+		log.Error(err)
 		reply := gosocks5.NewReply(gosocks5.Failure, nil)
 		if err := reply.Write(conn); err != nil {
-			h.logger.Error(err)
+			log.Error(err)
 		}
-		h.logger.Debug(reply)
+		log.Debug(reply)
 		return
 	}
 
 	socksAddr := gosocks5.Addr{}
 	if err := socksAddr.ParseFrom(ln.Addr().String()); err != nil {
-		h.logger.Warn(err)
+		log.Warn(err)
 	}
 
 	// Issue: may not reachable when host has multi-interface
@@ -52,22 +53,22 @@ func (h *socks5Handler) bindLocal(ctx context.Context, conn net.Conn, network, a
 	socksAddr.Type = 0
 	reply := gosocks5.NewReply(gosocks5.Succeeded, &socksAddr)
 	if err := reply.Write(conn); err != nil {
-		h.logger.Error(err)
+		log.Error(err)
 		ln.Close()
 		return
 	}
-	h.logger.Debug(reply)
+	log.Debug(reply)
 
-	h.logger = h.logger.WithFields(map[string]interface{}{
+	log = log.WithFields(map[string]interface{}{
 		"bind": fmt.Sprintf("%s/%s", ln.Addr(), ln.Addr().Network()),
 	})
 
-	h.logger.Debugf("bind on %s OK", ln.Addr())
+	log.Debugf("bind on %s OK", ln.Addr())
 
-	h.serveBind(ctx, conn, ln)
+	h.serveBind(ctx, conn, ln, log)
 }
 
-func (h *socks5Handler) serveBind(ctx context.Context, conn net.Conn, ln net.Listener) {
+func (h *socks5Handler) serveBind(ctx context.Context, conn net.Conn, ln net.Listener, log logger.Logger) {
 	var rc net.Conn
 	accept := func() <-chan error {
 		errc := make(chan error, 1)
@@ -105,38 +106,42 @@ func (h *socks5Handler) serveBind(ctx context.Context, conn net.Conn, ln net.Lis
 	select {
 	case err := <-accept():
 		if err != nil {
-			h.logger.Error(err)
+			log.Error(err)
 
 			reply := gosocks5.NewReply(gosocks5.Failure, nil)
 			if err := reply.Write(pc2); err != nil {
-				h.logger.Error(err)
+				log.Error(err)
 			}
-			h.logger.Debug(reply)
+			log.Debug(reply)
 
 			return
 		}
 		defer rc.Close()
 
-		h.logger.Debugf("peer %s accepted", rc.RemoteAddr())
+		log.Debugf("peer %s accepted", rc.RemoteAddr())
+
+		log = log.WithFields(map[string]interface{}{
+			"local":  rc.LocalAddr().String(),
+			"remote": rc.RemoteAddr().String(),
+		})
 
 		raddr := gosocks5.Addr{}
 		raddr.ParseFrom(rc.RemoteAddr().String())
 		reply := gosocks5.NewReply(gosocks5.Succeeded, &raddr)
 		if err := reply.Write(pc2); err != nil {
-			h.logger.Error(err)
+			log.Error(err)
 		}
-		h.logger.Debug(reply)
+		log.Debug(reply)
 
 		start := time.Now()
-		h.logger.Infof("%s <-> %s", conn.RemoteAddr(), raddr.String())
+		log.Infof("%s <-> %s", rc.LocalAddr(), rc.RemoteAddr())
 		handler.Transport(pc2, rc)
-		h.logger.
-			WithFields(map[string]interface{}{"duration": time.Since(start)}).
-			Infof("%s >-< %s", conn.RemoteAddr(), raddr.String())
+		log.WithFields(map[string]interface{}{"duration": time.Since(start)}).
+			Infof("%s >-< %s", rc.LocalAddr(), rc.RemoteAddr())
 
 	case err := <-pipe():
 		if err != nil {
-			h.logger.Error(err)
+			log.Error(err)
 		}
 		ln.Close()
 		return

pkg/handler/socks/v5/connect.go

@@ -8,20 +8,21 @@ import (
 
 	"github.com/go-gost/gosocks5"
 	"github.com/go-gost/gost/pkg/handler"
+	"github.com/go-gost/gost/pkg/logger"
 )
 
-func (h *socks5Handler) handleConnect(ctx context.Context, conn net.Conn, network, address string) {
-	h.logger = h.logger.WithFields(map[string]interface{}{
+func (h *socks5Handler) handleConnect(ctx context.Context, conn net.Conn, network, address string, log logger.Logger) {
+	log = log.WithFields(map[string]interface{}{
 		"dst": fmt.Sprintf("%s/%s", address, network),
 		"cmd": "connect",
 	})
-	h.logger.Infof("%s >> %s", conn.RemoteAddr(), address)
+	log.Infof("%s >> %s", conn.RemoteAddr(), address)
 
 	if h.options.Bypass != nil && h.options.Bypass.Contains(address) {
 		resp := gosocks5.NewReply(gosocks5.NotAllowed, nil)
 		resp.Write(conn)
-		h.logger.Debug(resp)
-		h.logger.Info("bypass: ", address)
+		log.Debug(resp)
+		log.Info("bypass: ", address)
 		return
 	}
 
@@ -29,7 +30,7 @@ func (h *socks5Handler) handleConnect(ctx context.Context, conn net.Conn, networ
 	if err != nil {
 		resp := gosocks5.NewReply(gosocks5.NetUnreachable, nil)
 		resp.Write(conn)
-		h.logger.Debug(resp)
+		log.Debug(resp)
 		return
 	}
 
@@ -37,17 +38,15 @@ func (h *socks5Handler) handleConnect(ctx context.Context, conn net.Conn, networ
 
 	resp := gosocks5.NewReply(gosocks5.Succeeded, nil)
 	if err := resp.Write(conn); err != nil {
-		h.logger.Error(err)
+		log.Error(err)
 		return
 	}
-	h.logger.Debug(resp)
+	log.Debug(resp)
 
 	t := time.Now()
-	h.logger.Infof("%s <-> %s", conn.RemoteAddr(), address)
+	log.Infof("%s <-> %s", conn.RemoteAddr(), address)
 	handler.Transport(conn, cc)
-	h.logger.
-		WithFields(map[string]interface{}{
-			"duration": time.Since(t),
-		}).
-		Infof("%s >-< %s", conn.RemoteAddr(), address)
+	log.WithFields(map[string]interface{}{
+		"duration": time.Since(t),
+	}).Infof("%s >-< %s", conn.RemoteAddr(), address)
 }

pkg/handler/socks/v5/handler.go

@@ -10,7 +10,6 @@ import (
 	auth_util "github.com/go-gost/gost/pkg/common/util/auth"
 	"github.com/go-gost/gost/pkg/common/util/socks"
 	"github.com/go-gost/gost/pkg/handler"
-	"github.com/go-gost/gost/pkg/logger"
 	md "github.com/go-gost/gost/pkg/metadata"
 	"github.com/go-gost/gost/pkg/registry"
 )
@@ -23,7 +22,6 @@ func init() {
 type socks5Handler struct {
 	selector gosocks5.Selector
 	router   *chain.Router
-	logger   logger.Logger
 	md       metadata
 	options  handler.Options
 }
@@ -44,7 +42,6 @@ func (h *socks5Handler) Init(md md.Metadata) (err error) {
 		return
 	}
 
-	h.logger = h.options.Logger
 	h.router = &chain.Router{
 		Retries:  h.options.Retries,
 		Chain:    h.options.Chain,
@@ -56,7 +53,7 @@ func (h *socks5Handler) Init(md md.Metadata) (err error) {
 	h.selector = &serverSelector{
 		Authenticator: auth_util.AuthFromUsers(h.options.Auths...),
 		TLSConfig:     h.options.TLSConfig,
-		logger:        h.logger,
+		logger:        h.options.Logger,
 		noTLS:         h.md.noTLS,
 	}
 
@@ -68,14 +65,14 @@ func (h *socks5Handler) Handle(ctx context.Context, conn net.Conn) {
 
 	start := time.Now()
 
-	h.logger = h.logger.WithFields(map[string]interface{}{
+	log := h.options.Logger.WithFields(map[string]interface{}{
 		"remote": conn.RemoteAddr().String(),
 		"local":  conn.LocalAddr().String(),
 	})
 
-	h.logger.Infof("%s <> %s", conn.RemoteAddr(), conn.LocalAddr())
+	log.Infof("%s <> %s", conn.RemoteAddr(), conn.LocalAddr())
 	defer func() {
-		h.logger.WithFields(map[string]interface{}{
+		log.WithFields(map[string]interface{}{
 			"duration": time.Since(start),
 		}).Infof("%s >< %s", conn.RemoteAddr(), conn.LocalAddr())
 	}()
@@ -87,30 +84,30 @@ func (h *socks5Handler) Handle(ctx context.Context, conn net.Conn) {
 	conn = gosocks5.ServerConn(conn, h.selector)
 	req, err := gosocks5.ReadRequest(conn)
 	if err != nil {
-		h.logger.Error(err)
+		log.Error(err)
 		return
 	}
-	h.logger.Debug(req)
+	log.Debug(req)
 	conn.SetReadDeadline(time.Time{})
 
 	address := req.Addr.String()
 
 	switch req.Cmd {
 	case gosocks5.CmdConnect:
-		h.handleConnect(ctx, conn, "tcp", address)
+		h.handleConnect(ctx, conn, "tcp", address, log)
 	case gosocks5.CmdBind:
-		h.handleBind(ctx, conn, "tcp", address)
+		h.handleBind(ctx, conn, "tcp", address, log)
 	case socks.CmdMuxBind:
-		h.handleMuxBind(ctx, conn, "tcp", address)
+		h.handleMuxBind(ctx, conn, "tcp", address, log)
 	case gosocks5.CmdUdp:
-		h.handleUDP(ctx, conn)
+		h.handleUDP(ctx, conn, log)
 	case socks.CmdUDPTun:
-		h.handleUDPTun(ctx, conn, "udp", address)
+		h.handleUDPTun(ctx, conn, "udp", address, log)
 	default:
-		h.logger.Errorf("unknown cmd: %d", req.Cmd)
+		log.Errorf("unknown cmd: %d", req.Cmd)
 		resp := gosocks5.NewReply(gosocks5.CmdUnsupported, nil)
 		resp.Write(conn)
-		h.logger.Debug(resp)
+		log.Debug(resp)
 		return
 	}
 }

pkg/handler/socks/v5/mbind.go

@@ -9,43 +9,44 @@ import (
 	"github.com/go-gost/gosocks5"
 	"github.com/go-gost/gost/pkg/common/util/mux"
 	"github.com/go-gost/gost/pkg/handler"
+	"github.com/go-gost/gost/pkg/logger"
 )
 
-func (h *socks5Handler) handleMuxBind(ctx context.Context, conn net.Conn, network, address string) {
-	h.logger = h.logger.WithFields(map[string]interface{}{
+func (h *socks5Handler) handleMuxBind(ctx context.Context, conn net.Conn, network, address string, log logger.Logger) {
+	log = log.WithFields(map[string]interface{}{
 		"dst": fmt.Sprintf("%s/%s", address, network),
 		"cmd": "mbind",
 	})
 
-	h.logger.Infof("%s >> %s", conn.RemoteAddr(), address)
+	log.Infof("%s >> %s", conn.RemoteAddr(), address)
 
 	if !h.md.enableBind {
 		reply := gosocks5.NewReply(gosocks5.NotAllowed, nil)
 		reply.Write(conn)
-		h.logger.Debug(reply)
-		h.logger.Error("BIND is diabled")
+		log.Debug(reply)
+		log.Error("BIND is diabled")
 		return
 	}
 
-	h.muxBindLocal(ctx, conn, network, address)
+	h.muxBindLocal(ctx, conn, network, address, log)
 }
 
-func (h *socks5Handler) muxBindLocal(ctx context.Context, conn net.Conn, network, address string) {
+func (h *socks5Handler) muxBindLocal(ctx context.Context, conn net.Conn, network, address string, log logger.Logger) {
 	ln, err := net.Listen(network, address) // strict mode: if the port already in use, it will return error
 	if err != nil {
-		h.logger.Error(err)
+		log.Error(err)
 		reply := gosocks5.NewReply(gosocks5.Failure, nil)
 		if err := reply.Write(conn); err != nil {
-			h.logger.Error(err)
+			log.Error(err)
 		}
-		h.logger.Debug(reply)
+		log.Debug(reply)
 		return
 	}
 
 	socksAddr := gosocks5.Addr{}
 	err = socksAddr.ParseFrom(ln.Addr().String())
 	if err != nil {
-		h.logger.Warn(err)
+		log.Warn(err)
 	}
 
 	// Issue: may not reachable when host has multi-interface
@@ -53,26 +54,26 @@ func (h *socks5Handler) muxBindLocal(ctx context.Context, conn net.Conn, network
 	socksAddr.Type = 0
 	reply := gosocks5.NewReply(gosocks5.Succeeded, &socksAddr)
 	if err := reply.Write(conn); err != nil {
-		h.logger.Error(err)
+		log.Error(err)
 		ln.Close()
 		return
 	}
-	h.logger.Debug(reply)
+	log.Debug(reply)
 
-	h.logger = h.logger.WithFields(map[string]interface{}{
+	log = log.WithFields(map[string]interface{}{
 		"bind": fmt.Sprintf("%s/%s", ln.Addr(), ln.Addr().Network()),
 	})
 
-	h.logger.Debugf("bind on %s OK", ln.Addr())
+	log.Debugf("bind on %s OK", ln.Addr())
 
-	h.serveMuxBind(ctx, conn, ln)
+	h.serveMuxBind(ctx, conn, ln, log)
 }
 
-func (h *socks5Handler) serveMuxBind(ctx context.Context, conn net.Conn, ln net.Listener) {
+func (h *socks5Handler) serveMuxBind(ctx context.Context, conn net.Conn, ln net.Listener, log logger.Logger) {
 	// Upgrade connection to multiplex stream.
 	session, err := mux.ClientSession(conn)
 	if err != nil {
-		h.logger.Error(err)
+		log.Error(err)
 		return
 	}
 	defer session.Close()
@@ -82,7 +83,7 @@ func (h *socks5Handler) serveMuxBind(ctx context.Context, conn net.Conn, ln net.
 		for {
 			conn, err := session.Accept()
 			if err != nil {
-				h.logger.Error(err)
+				log.Error(err)
 				return
 			}
 			conn.Close() // we do not handle incoming connections.
@@ -92,17 +93,21 @@ func (h *socks5Handler) serveMuxBind(ctx context.Context, conn net.Conn, ln net.
 	for {
 		rc, err := ln.Accept()
 		if err != nil {
-			h.logger.Error(err)
+			log.Error(err)
 			return
 		}
-		h.logger.Debugf("peer %s accepted", rc.RemoteAddr())
+		log.Debugf("peer %s accepted", rc.RemoteAddr())
 
 		go func(c net.Conn) {
 			defer c.Close()
 
+			log = log.WithFields(map[string]interface{}{
+				"local":  rc.LocalAddr().String(),
+				"remote": rc.RemoteAddr().String(),
+			})
 			sc, err := session.GetConn()
 			if err != nil {
-				h.logger.Error(err)
+				log.Error(err)
 				return
 			}
 			defer sc.Close()
@@ -113,18 +118,17 @@ func (h *socks5Handler) serveMuxBind(ctx context.Context, conn net.Conn, ln net.
 				addr.ParseFrom(c.RemoteAddr().String())
 				reply := gosocks5.NewReply(gosocks5.Succeeded, &addr)
 				if err := reply.Write(sc); err != nil {
-					h.logger.Error(err)
+					log.Error(err)
 					return
 				}
-				h.logger.Debug(reply)
+				log.Debug(reply)
 			}
 
 			t := time.Now()
-			h.logger.Infof("%s <-> %s", conn.RemoteAddr(), c.RemoteAddr().String())
+			log.Infof("%s <-> %s", c.LocalAddr(), c.RemoteAddr())
 			handler.Transport(sc, c)
-			h.logger.
-				WithFields(map[string]interface{}{"duration": time.Since(t)}).
-				Infof("%s >-< %s", conn.RemoteAddr(), c.RemoteAddr().String())
+			log.WithFields(map[string]interface{}{"duration": time.Since(t)}).
+				Infof("%s >-< %s", c.LocalAddr(), c.RemoteAddr())
 		}(rc)
 	}
 }

pkg/handler/socks/v5/udp.go

@@ -11,27 +11,28 @@ import (
 	"github.com/go-gost/gosocks5"
 	"github.com/go-gost/gost/pkg/common/util/socks"
 	"github.com/go-gost/gost/pkg/handler"
+	"github.com/go-gost/gost/pkg/logger"
 )
 
-func (h *socks5Handler) handleUDP(ctx context.Context, conn net.Conn) {
-	h.logger = h.logger.WithFields(map[string]interface{}{
+func (h *socks5Handler) handleUDP(ctx context.Context, conn net.Conn, log logger.Logger) {
+	log = log.WithFields(map[string]interface{}{
 		"cmd": "udp",
 	})
 
 	if !h.md.enableUDP {
 		reply := gosocks5.NewReply(gosocks5.NotAllowed, nil)
 		reply.Write(conn)
-		h.logger.Debug(reply)
-		h.logger.Error("UDP relay is diabled")
+		log.Debug(reply)
+		log.Error("UDP relay is diabled")
 		return
 	}
 
 	cc, err := net.ListenUDP("udp", nil)
 	if err != nil {
-		h.logger.Error(err)
+		log.Error(err)
 		reply := gosocks5.NewReply(gosocks5.Failure, nil)
 		reply.Write(conn)
-		h.logger.Debug(reply)
+		log.Debug(reply)
 		return
 	}
 	defer cc.Close()
@@ -42,41 +43,40 @@ func (h *socks5Handler) handleUDP(ctx context.Context, conn net.Conn) {
 	saddr.Host, _, _ = net.SplitHostPort(conn.LocalAddr().String()) // replace the IP to the out-going interface's
 	reply := gosocks5.NewReply(gosocks5.Succeeded, &saddr)
 	if err := reply.Write(conn); err != nil {
-		h.logger.Error(err)
+		log.Error(err)
 		return
 	}
-	h.logger.Debug(reply)
+	log.Debug(reply)
 
-	h.logger = h.logger.WithFields(map[string]interface{}{
+	log = log.WithFields(map[string]interface{}{
 		"bind": fmt.Sprintf("%s/%s", cc.LocalAddr(), cc.LocalAddr().Network()),
 	})
-	h.logger.Debugf("bind on %s OK", cc.LocalAddr())
+	log.Debugf("bind on %s OK", cc.LocalAddr())
 
 	// obtain a udp connection
 	c, err := h.router.Dial(ctx, "udp", "") // UDP association
 	if err != nil {
-		h.logger.Error(err)
+		log.Error(err)
 		return
 	}
 	defer c.Close()
 
 	pc, ok := c.(net.PacketConn)
 	if !ok {
-		h.logger.Errorf("wrong connection type")
+		log.Errorf("wrong connection type")
 		return
 	}
 
 	relay := handler.NewUDPRelay(socks.UDPConn(cc, h.md.udpBufferSize), pc).
 		WithBypass(h.options.Bypass).
-		WithLogger(h.logger)
+		WithLogger(log)
 	relay.SetBufferSize(h.md.udpBufferSize)
 
 	go relay.Run()
 
 	t := time.Now()
-	h.logger.Infof("%s <-> %s", conn.RemoteAddr(), cc.LocalAddr())
+	log.Infof("%s <-> %s", conn.RemoteAddr(), cc.LocalAddr())
 	io.Copy(ioutil.Discard, conn)
-	h.logger.
-		WithFields(map[string]interface{}{"duration": time.Since(t)}).
+	log.WithFields(map[string]interface{}{"duration": time.Since(t)}).
 		Infof("%s >-< %s", conn.RemoteAddr(), cc.LocalAddr())
 }

pkg/handler/socks/v5/udp_tun.go

@@ -8,54 +8,53 @@ import (
 	"github.com/go-gost/gosocks5"
 	"github.com/go-gost/gost/pkg/common/util/socks"
 	"github.com/go-gost/gost/pkg/handler"
+	"github.com/go-gost/gost/pkg/logger"
 )
 
-func (h *socks5Handler) handleUDPTun(ctx context.Context, conn net.Conn, network, address string) {
-	h.logger = h.logger.WithFields(map[string]interface{}{
+func (h *socks5Handler) handleUDPTun(ctx context.Context, conn net.Conn, network, address string, log logger.Logger) {
+	log = log.WithFields(map[string]interface{}{
 		"cmd": "udp-tun",
 	})
 
 	if !h.md.enableUDP {
 		reply := gosocks5.NewReply(gosocks5.NotAllowed, nil)
 		reply.Write(conn)
-		h.logger.Debug(reply)
-		h.logger.Error("UDP relay is diabled")
+		log.Debug(reply)
+		log.Error("UDP relay is diabled")
 		return
 	}
 
 	// dummy bind
 	reply := gosocks5.NewReply(gosocks5.Succeeded, nil)
 	if err := reply.Write(conn); err != nil {
-		h.logger.Error(err)
+		log.Error(err)
 		return
 	}
-	h.logger.Debug(reply)
+	log.Debug(reply)
 
 	// obtain a udp connection
 	c, err := h.router.Dial(ctx, "udp", "") // UDP association
 	if err != nil {
-		h.logger.Error(err)
+		log.Error(err)
 		return
 	}
 	defer c.Close()
 
 	pc, ok := c.(net.PacketConn)
 	if !ok {
-		h.logger.Errorf("wrong connection type")
+		log.Errorf("wrong connection type")
 		return
 	}
 
 	relay := handler.NewUDPRelay(socks.UDPTunServerConn(conn), pc).
 		WithBypass(h.options.Bypass).
-		WithLogger(h.logger)
+		WithLogger(log)
 	relay.SetBufferSize(h.md.udpBufferSize)
 
 	t := time.Now()
-	h.logger.Infof("%s <-> %s", conn.RemoteAddr(), pc.LocalAddr())
+	log.Infof("%s <-> %s", conn.RemoteAddr(), pc.LocalAddr())
 	relay.Run()
-	h.logger.
-		WithFields(map[string]interface{}{
-			"duration": time.Since(t),
-		}).
-		Infof("%s >-< %s", conn.RemoteAddr(), pc.LocalAddr())
+	log.WithFields(map[string]interface{}{
+		"duration": time.Since(t),
+	}).Infof("%s >-< %s", conn.RemoteAddr(), pc.LocalAddr())
 }