feat: extend TCP keepalive support to all TCP-based listeners and dialers

Add configurable TCP keepalive (keepalive, keepalive.idle,
keepalive.interval, keepalive.count) to all TCP-based transport types:
tls, mtls, mtcp, ws/wss, mws/mwss, http2, ssh, sshd listeners and
tls, mtls, mtcp, ws/wss, mws/mwss, ssh, sshd dialers.

For types that already use "keepalive" for an app-level protocol
(grpc listener/dialer, ws/mws dialers, ssh/sshd dialers), the TCP
keepalive parameters are exposed under the tcp.keepalive.* prefix to
avoid ambiguity.

Also extract shared helpers into internal/net/keepalive.go:
- WrapKeepaliveListener: applies KeepAliveConfig on every accepted TCPConn
- ApplyKeepalive: applies KeepAliveConfig to a single TCPConn

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

dialer/grpc/dialer.go

@@ -8,6 +8,7 @@ import (
 	"github.com/go-gost/core/dialer"
 	md "github.com/go-gost/core/metadata"
 	xctx "github.com/go-gost/x/ctx"
+	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
 	pb "github.com/go-gost/x/internal/util/grpc/proto"
 	"github.com/go-gost/x/registry"
@@ -78,6 +79,15 @@ func (d *grpcDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialO
 					return nil, err
 				}
 
+				if d.md.tcpKeepalive {
+					xnet.ApplyKeepalive(conn, net.KeepAliveConfig{
+						Enable:   true,
+						Idle:     d.md.tcpKeepaliveIdle,
+						Interval: d.md.tcpKeepaliveInterval,
+						Count:    d.md.tcpKeepaliveCount,
+					})
+				}
+
 				conn = proxyproto.WrapClientConn(
 					d.options.ProxyProtocol,
 					xctx.SrcAddrFromContext(ctx),

dialer/grpc/metadata.go

@@ -16,6 +16,11 @@ type metadata struct {
 	keepaliveTimeout             time.Duration
 	keepalivePermitWithoutStream bool
 	minConnectTimeout            time.Duration
+
+	tcpKeepalive         bool
+	tcpKeepaliveIdle     time.Duration
+	tcpKeepaliveInterval time.Duration
+	tcpKeepaliveCount    int
 }
 
 func (d *grpcDialer) parseMetadata(md mdata.Metadata) (err error) {
@@ -39,5 +44,10 @@ func (d *grpcDialer) parseMetadata(md mdata.Metadata) (err error) {
 		d.md.minConnectTimeout = 30 * time.Second
 	}
 
+	d.md.tcpKeepalive = mdutil.GetBool(md, "tcp.keepalive")
+	d.md.tcpKeepaliveIdle = mdutil.GetDuration(md, "tcp.keepalive.idle")
+	d.md.tcpKeepaliveInterval = mdutil.GetDuration(md, "tcp.keepalive.interval")
+	d.md.tcpKeepaliveCount = mdutil.GetInt(md, "tcp.keepalive.count")
+
 	return
 }

dialer/mtcp/dialer.go

@@ -11,6 +11,7 @@ import (
 	"github.com/go-gost/core/logger"
 	md "github.com/go-gost/core/metadata"
 	xctx "github.com/go-gost/x/ctx"
+	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
 	"github.com/go-gost/x/internal/util/mux"
 	"github.com/go-gost/x/registry"
@@ -74,6 +75,15 @@ func (d *mtcpDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialO
 			return
 		}
 
+		if d.md.keepalive {
+			xnet.ApplyKeepalive(conn, net.KeepAliveConfig{
+				Enable:   true,
+				Idle:     d.md.keepaliveIdle,
+				Interval: d.md.keepaliveInterval,
+				Count:    d.md.keepaliveCount,
+			})
+		}
+
 		conn = proxyproto.WrapClientConn(
 			d.options.ProxyProtocol,
 			xctx.SrcAddrFromContext(ctx),

dialer/mtcp/metadata.go

@@ -11,11 +11,21 @@ import (
 type metadata struct {
 	handshakeTimeout time.Duration
 	muxCfg           *mux.Config
+
+	keepalive         bool
+	keepaliveIdle     time.Duration
+	keepaliveInterval time.Duration
+	keepaliveCount    int
 }
 
 func (d *mtcpDialer) parseMetadata(md mdata.Metadata) (err error) {
 	d.md.handshakeTimeout = mdutil.GetDuration(md, "handshakeTimeout")
 
+	d.md.keepalive = mdutil.GetBool(md, "keepalive")
+	d.md.keepaliveIdle = mdutil.GetDuration(md, "keepalive.idle")
+	d.md.keepaliveInterval = mdutil.GetDuration(md, "keepalive.interval")
+	d.md.keepaliveCount = mdutil.GetInt(md, "keepalive.count")
+
 	d.md.muxCfg = &mux.Config{
 		Version:           mdutil.GetInt(md, "mux.version"),
 		KeepAliveInterval: mdutil.GetDuration(md, "mux.keepaliveInterval"),

dialer/mtls/dialer.go

@@ -12,6 +12,7 @@ import (
 	"github.com/go-gost/core/logger"
 	md "github.com/go-gost/core/metadata"
 	xctx "github.com/go-gost/x/ctx"
+	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
 	"github.com/go-gost/x/internal/util/mux"
 	"github.com/go-gost/x/registry"
@@ -75,6 +76,15 @@ func (d *mtlsDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialO
 			return
 		}
 
+		if d.md.keepalive {
+			xnet.ApplyKeepalive(conn, net.KeepAliveConfig{
+				Enable:   true,
+				Idle:     d.md.keepaliveIdle,
+				Interval: d.md.keepaliveInterval,
+				Count:    d.md.keepaliveCount,
+			})
+		}
+
 		conn = proxyproto.WrapClientConn(
 			d.options.ProxyProtocol,
 			xctx.SrcAddrFromContext(ctx),

dialer/mtls/metadata.go

@@ -11,11 +11,21 @@ import (
 type metadata struct {
 	handshakeTimeout time.Duration
 	muxCfg           *mux.Config
+
+	keepalive         bool
+	keepaliveIdle     time.Duration
+	keepaliveInterval time.Duration
+	keepaliveCount    int
 }
 
 func (d *mtlsDialer) parseMetadata(md mdata.Metadata) (err error) {
 	d.md.handshakeTimeout = mdutil.GetDuration(md, "handshakeTimeout")
 
+	d.md.keepalive = mdutil.GetBool(md, "keepalive")
+	d.md.keepaliveIdle = mdutil.GetDuration(md, "keepalive.idle")
+	d.md.keepaliveInterval = mdutil.GetDuration(md, "keepalive.interval")
+	d.md.keepaliveCount = mdutil.GetInt(md, "keepalive.count")
+
 	d.md.muxCfg = &mux.Config{
 		Version:           mdutil.GetInt(md, "mux.version"),
 		KeepAliveInterval: mdutil.GetDuration(md, "mux.keepaliveInterval"),

dialer/mws/dialer.go

@@ -12,6 +12,7 @@ import (
 	"github.com/go-gost/core/logger"
 	md "github.com/go-gost/core/metadata"
 	xctx "github.com/go-gost/x/ctx"
+	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
 	"github.com/go-gost/x/internal/util/mux"
 	ws_util "github.com/go-gost/x/internal/util/ws"
@@ -89,6 +90,15 @@ func (d *mwsDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOp
 			return
 		}
 
+		if d.md.tcpKeepalive {
+			xnet.ApplyKeepalive(conn, net.KeepAliveConfig{
+				Enable:   true,
+				Idle:     d.md.tcpKeepaliveIdle,
+				Interval: d.md.tcpKeepaliveInterval,
+				Count:    d.md.tcpKeepaliveCount,
+			})
+		}
+
 		conn = proxyproto.WrapClientConn(
 			d.options.ProxyProtocol,
 			xctx.SrcAddrFromContext(ctx),

dialer/mws/metadata.go

@@ -27,6 +27,11 @@ type metadata struct {
 	header            http.Header
 	keepaliveInterval time.Duration
 	muxCfg            *mux.Config
+
+	tcpKeepalive         bool
+	tcpKeepaliveIdle     time.Duration
+	tcpKeepaliveInterval time.Duration
+	tcpKeepaliveCount    int
 }
 
 func (d *mwsDialer) parseMetadata(md mdata.Metadata) (err error) {
@@ -67,5 +72,10 @@ func (d *mwsDialer) parseMetadata(md mdata.Metadata) (err error) {
 		}
 	}
 
+	d.md.tcpKeepalive = mdutil.GetBool(md, "tcp.keepalive")
+	d.md.tcpKeepaliveIdle = mdutil.GetDuration(md, "tcp.keepalive.idle")
+	d.md.tcpKeepaliveInterval = mdutil.GetDuration(md, "tcp.keepalive.interval")
+	d.md.tcpKeepaliveCount = mdutil.GetInt(md, "tcp.keepalive.count")
+
 	return
 }

dialer/ssh/dialer.go

@@ -9,6 +9,7 @@ import (
 	"github.com/go-gost/core/dialer"
 	md "github.com/go-gost/core/metadata"
 	xctx "github.com/go-gost/x/ctx"
+	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
 	ssh_util "github.com/go-gost/x/internal/util/ssh"
 	"github.com/go-gost/x/registry"
@@ -70,6 +71,14 @@ func (d *sshDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOp
 		if err != nil {
 			return
 		}
+		if d.md.tcpKeepalive {
+			xnet.ApplyKeepalive(conn, net.KeepAliveConfig{
+				Enable:   true,
+				Idle:     d.md.tcpKeepaliveIdle,
+				Interval: d.md.tcpKeepaliveInterval,
+				Count:    d.md.tcpKeepaliveCount,
+			})
+		}
 		if d.md.handshakeTimeout > 0 {
 			conn.SetDeadline(time.Now().Add(d.md.handshakeTimeout))
 			defer conn.SetDeadline(time.Time{})

dialer/ssh/metadata.go

@@ -19,6 +19,11 @@ type metadata struct {
 	keepaliveInterval time.Duration
 	keepaliveTimeout  time.Duration
 	keepaliveRetries  int
+
+	tcpKeepalive         bool
+	tcpKeepaliveIdle     time.Duration
+	tcpKeepaliveInterval time.Duration
+	tcpKeepaliveCount    int
 }
 
 func (d *sshDialer) parseMetadata(md mdata.Metadata) (err error) {
@@ -66,5 +71,10 @@ func (d *sshDialer) parseMetadata(md mdata.Metadata) (err error) {
 		d.md.keepaliveRetries = mdutil.GetInt(md, "keepalive.retries")
 	}
 
+	d.md.tcpKeepalive = mdutil.GetBool(md, "tcp.keepalive")
+	d.md.tcpKeepaliveIdle = mdutil.GetDuration(md, "tcp.keepalive.idle")
+	d.md.tcpKeepaliveInterval = mdutil.GetDuration(md, "tcp.keepalive.interval")
+	d.md.tcpKeepaliveCount = mdutil.GetInt(md, "tcp.keepalive.count")
+
 	return
 }

dialer/sshd/dialer.go

@@ -10,6 +10,7 @@ import (
 	"github.com/go-gost/core/dialer"
 	md "github.com/go-gost/core/metadata"
 	xctx "github.com/go-gost/x/ctx"
+	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
 	ssh_util "github.com/go-gost/x/internal/util/ssh"
 	"github.com/go-gost/x/registry"
@@ -72,6 +73,14 @@ func (d *sshdDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialO
 		if err != nil {
 			return
 		}
+		if d.md.tcpKeepalive {
+			xnet.ApplyKeepalive(conn, net.KeepAliveConfig{
+				Enable:   true,
+				Idle:     d.md.tcpKeepaliveIdle,
+				Interval: d.md.tcpKeepaliveInterval,
+				Count:    d.md.tcpKeepaliveCount,
+			})
+		}
 
 		if d.md.handshakeTimeout > 0 {
 			conn.SetDeadline(time.Now().Add(d.md.handshakeTimeout))

dialer/sshd/metadata.go

@@ -19,6 +19,11 @@ type metadata struct {
 	keepaliveInterval time.Duration
 	keepaliveTimeout  time.Duration
 	keepaliveRetries  int
+
+	tcpKeepalive         bool
+	tcpKeepaliveIdle     time.Duration
+	tcpKeepaliveInterval time.Duration
+	tcpKeepaliveCount    int
 }
 
 func (d *sshdDialer) parseMetadata(md mdata.Metadata) (err error) {
@@ -64,5 +69,11 @@ func (d *sshdDialer) parseMetadata(md mdata.Metadata) (err error) {
 		d.md.keepaliveTimeout = mdutil.GetDuration(md, "keepalive.timeout")
 		d.md.keepaliveRetries = mdutil.GetInt(md, "keepalive.retries")
 	}
+
+	d.md.tcpKeepalive = mdutil.GetBool(md, "tcp.keepalive")
+	d.md.tcpKeepaliveIdle = mdutil.GetDuration(md, "tcp.keepalive.idle")
+	d.md.tcpKeepaliveInterval = mdutil.GetDuration(md, "tcp.keepalive.interval")
+	d.md.tcpKeepaliveCount = mdutil.GetInt(md, "tcp.keepalive.count")
+
 	return
 }

dialer/tls/dialer.go

@@ -10,6 +10,7 @@ import (
 	"github.com/go-gost/core/logger"
 	md "github.com/go-gost/core/metadata"
 	xctx "github.com/go-gost/x/ctx"
+	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
 	"github.com/go-gost/x/registry"
 )
@@ -51,6 +52,15 @@ func (d *tlsDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOp
 		d.log.Error(err)
 	}
 
+	if d.md.keepalive {
+		xnet.ApplyKeepalive(conn, net.KeepAliveConfig{
+			Enable:   true,
+			Idle:     d.md.keepaliveIdle,
+			Interval: d.md.keepaliveInterval,
+			Count:    d.md.keepaliveCount,
+		})
+	}
+
 	conn = proxyproto.WrapClientConn(
 		d.options.ProxyProtocol,
 		xctx.SrcAddrFromContext(ctx),

dialer/tls/metadata.go

@@ -9,6 +9,11 @@ import (
 
 type metadata struct {
 	handshakeTimeout time.Duration
+
+	keepalive         bool
+	keepaliveIdle     time.Duration
+	keepaliveInterval time.Duration
+	keepaliveCount    int
 }
 
 func (d *tlsDialer) parseMetadata(md mdata.Metadata) (err error) {
@@ -18,5 +23,10 @@ func (d *tlsDialer) parseMetadata(md mdata.Metadata) (err error) {
 
 	d.md.handshakeTimeout = mdutil.GetDuration(md, handshakeTimeout)
 
+	d.md.keepalive = mdutil.GetBool(md, "keepalive")
+	d.md.keepaliveIdle = mdutil.GetDuration(md, "keepalive.idle")
+	d.md.keepaliveInterval = mdutil.GetDuration(md, "keepalive.interval")
+	d.md.keepaliveCount = mdutil.GetInt(md, "keepalive.count")
+
 	return
 }

dialer/ws/dialer.go

@@ -9,6 +9,7 @@ import (
 	"github.com/go-gost/core/dialer"
 	md "github.com/go-gost/core/metadata"
 	xctx "github.com/go-gost/x/ctx"
+	xnet "github.com/go-gost/x/internal/net"
 	"github.com/go-gost/x/internal/net/proxyproto"
 	ws_util "github.com/go-gost/x/internal/util/ws"
 	"github.com/go-gost/x/registry"
@@ -64,6 +65,15 @@ func (d *wsDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialOpt
 		d.options.Logger.Error(err)
 	}
 
+	if d.md.tcpKeepalive {
+		xnet.ApplyKeepalive(conn, net.KeepAliveConfig{
+			Enable:   true,
+			Idle:     d.md.tcpKeepaliveIdle,
+			Interval: d.md.tcpKeepaliveInterval,
+			Count:    d.md.tcpKeepaliveCount,
+		})
+	}
+
 	conn = proxyproto.WrapClientConn(
 		d.options.ProxyProtocol,
 		xctx.SrcAddrFromContext(ctx),

dialer/ws/metadata.go

@@ -25,6 +25,11 @@ type metadata struct {
 
 	header            http.Header
 	keepaliveInterval time.Duration
+
+	tcpKeepalive         bool
+	tcpKeepaliveIdle     time.Duration
+	tcpKeepaliveInterval time.Duration
+	tcpKeepaliveCount    int
 }
 
 func (d *wsDialer) parseMetadata(md mdata.Metadata) (err error) {
@@ -56,5 +61,10 @@ func (d *wsDialer) parseMetadata(md mdata.Metadata) (err error) {
 		}
 	}
 
+	d.md.tcpKeepalive = mdutil.GetBool(md, "tcp.keepalive")
+	d.md.tcpKeepaliveIdle = mdutil.GetDuration(md, "tcp.keepalive.idle")
+	d.md.tcpKeepaliveInterval = mdutil.GetDuration(md, "tcp.keepalive.interval")
+	d.md.tcpKeepaliveCount = mdutil.GetInt(md, "tcp.keepalive.count")
+
 	return
 }

internal/net/keepalive.go

@@ -0,0 +1,32 @@
+package net
+
+import "net"
+
+// WrapKeepaliveListener wraps ln so that TCP keepalive config is applied to
+// every accepted *net.TCPConn before it enters the middleware wrapper chain.
+func WrapKeepaliveListener(ln net.Listener, cfg net.KeepAliveConfig) net.Listener {
+	return &keepaliveListener{Listener: ln, cfg: cfg}
+}
+
+// ApplyKeepalive applies cfg to conn if it is a *net.TCPConn.
+func ApplyKeepalive(conn net.Conn, cfg net.KeepAliveConfig) {
+	if tc, ok := conn.(*net.TCPConn); ok {
+		tc.SetKeepAliveConfig(cfg)
+	}
+}
+
+type keepaliveListener struct {
+	net.Listener
+	cfg net.KeepAliveConfig
+}
+
+func (l *keepaliveListener) Accept() (net.Conn, error) {
+	conn, err := l.Listener.Accept()
+	if err != nil {
+		return nil, err
+	}
+	if tc, ok := conn.(*net.TCPConn); ok {
+		tc.SetKeepAliveConfig(l.cfg)
+	}
+	return conn, nil
+}

listener/grpc/listener.go

@@ -66,6 +66,16 @@ func (l *grpcListener) Init(md md.Metadata) (err error) {
 	if err != nil {
 		return
 	}
+	if l.md.tcpKeepalive {
+		ln = xnet.WrapKeepaliveListener(ln, net.KeepAliveConfig{
+			Enable:   true,
+			Idle:     l.md.tcpKeepaliveIdle,
+			Interval: l.md.tcpKeepaliveInterval,
+			Count:    l.md.tcpKeepaliveCount,
+		})
+		l.logger.Debugf("tcp keepalive enabled: idle=%v interval=%v count=%d",
+			l.md.tcpKeepaliveIdle, l.md.tcpKeepaliveInterval, l.md.tcpKeepaliveCount)
+	}
 
 	ln = proxyproto.WrapListener(l.options.ProxyProtocol, ln, 10*time.Second)
 	ln = metrics.WrapListener(l.options.Service, ln)

listener/grpc/metadata.go

@@ -22,6 +22,11 @@ type metadata struct {
 	keepalivePermitWithoutStream bool
 	keepaliveMaxConnectionIdle   time.Duration
 	mptcp                        bool
+
+	tcpKeepalive         bool
+	tcpKeepaliveIdle     time.Duration
+	tcpKeepaliveInterval time.Duration
+	tcpKeepaliveCount    int
 }
 
 func (l *grpcListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -50,8 +55,12 @@ func (l *grpcListener) parseMetadata(md mdata.Metadata) (err error) {
 
 		l.md.keepalivePermitWithoutStream = mdutil.GetBool(md, "grpc.keepalive.permitWithoutStream", "keepalive.permitWithoutStream")
 		l.md.keepaliveMaxConnectionIdle = mdutil.GetDuration(md, "grpc.keepalive.maxConnectionIdle", "keepalive.maxConnectionIdle")
-		l.md.mptcp = mdutil.GetBool(md, "mptcp")
 	}
+	l.md.mptcp = mdutil.GetBool(md, "mptcp")
+	l.md.tcpKeepalive = mdutil.GetBool(md, "tcp.keepalive")
+	l.md.tcpKeepaliveIdle = mdutil.GetDuration(md, "tcp.keepalive.idle")
+	l.md.tcpKeepaliveInterval = mdutil.GetDuration(md, "tcp.keepalive.interval")
+	l.md.tcpKeepaliveCount = mdutil.GetInt(md, "tcp.keepalive.count")
 
 	return
 }

listener/http2/listener.go

@@ -93,6 +93,16 @@ func (l *http2Listener) Init(md md.Metadata) (err error) {
 	if err != nil {
 		return err
 	}
+	if l.md.keepalive {
+		ln = xnet.WrapKeepaliveListener(ln, net.KeepAliveConfig{
+			Enable:   true,
+			Idle:     l.md.keepaliveIdle,
+			Interval: l.md.keepaliveInterval,
+			Count:    l.md.keepaliveCount,
+		})
+		l.log.Debugf("tcp keepalive enabled: idle=%v interval=%v count=%d",
+			l.md.keepaliveIdle, l.md.keepaliveInterval, l.md.keepaliveCount)
+	}
 	l.addr = ln.Addr()
 	ln = proxyproto.WrapListener(l.options.ProxyProtocol, ln, 10*time.Second)
 	ln = metrics.WrapListener(l.options.Service, ln)

listener/http2/metadata.go

@@ -1,6 +1,8 @@
 package http2
 
 import (
+	"time"
+
 	mdata "github.com/go-gost/core/metadata"
 	mdutil "github.com/go-gost/x/metadata/util"
 )
@@ -12,6 +14,11 @@ const (
 type metadata struct {
 	backlog int
 	mptcp   bool
+
+	keepalive         bool
+	keepaliveIdle     time.Duration
+	keepaliveInterval time.Duration
+	keepaliveCount    int
 }
 
 func (l *http2Listener) parseMetadata(md mdata.Metadata) (err error) {
@@ -25,5 +32,10 @@ func (l *http2Listener) parseMetadata(md mdata.Metadata) (err error) {
 	}
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
+	l.md.keepalive = mdutil.GetBool(md, "keepalive")
+	l.md.keepaliveIdle = mdutil.GetDuration(md, "keepalive.idle")
+	l.md.keepaliveInterval = mdutil.GetDuration(md, "keepalive.interval")
+	l.md.keepaliveCount = mdutil.GetInt(md, "keepalive.count")
+
 	return
 }

listener/mtcp/listener.go

@@ -63,6 +63,16 @@ func (l *mtcpListener) Init(md md.Metadata) (err error) {
 	if err != nil {
 		return
 	}
+	if l.md.keepalive {
+		ln = xnet.WrapKeepaliveListener(ln, net.KeepAliveConfig{
+			Enable:   true,
+			Idle:     l.md.keepaliveIdle,
+			Interval: l.md.keepaliveInterval,
+			Count:    l.md.keepaliveCount,
+		})
+		l.logger.Debugf("tcp keepalive enabled: idle=%v interval=%v count=%d",
+			l.md.keepaliveIdle, l.md.keepaliveInterval, l.md.keepaliveCount)
+	}
 
 	l.logger.Debugf("pp: %d", l.options.ProxyProtocol)
 

listener/mtcp/metadata.go

@@ -1,6 +1,8 @@
 package mtcp
 
 import (
+	"time"
+
 	md "github.com/go-gost/core/metadata"
 	"github.com/go-gost/x/internal/util/mux"
 	mdutil "github.com/go-gost/x/metadata/util"
@@ -11,9 +13,13 @@ const (
 )
 
 type metadata struct {
-	mptcp   bool
+	mptcp             bool
-	muxCfg  *mux.Config
+	muxCfg            *mux.Config
-	backlog int
+	backlog           int
+	keepalive         bool
+	keepaliveIdle     time.Duration
+	keepaliveInterval time.Duration
+	keepaliveCount    int
 }
 
 func (l *mtcpListener) parseMetadata(md md.Metadata) (err error) {
@@ -37,5 +43,9 @@ func (l *mtcpListener) parseMetadata(md md.Metadata) (err error) {
 		l.md.backlog = defaultBacklog
 	}
 
+	l.md.keepalive = mdutil.GetBool(md, "keepalive")
+	l.md.keepaliveIdle = mdutil.GetDuration(md, "keepalive.idle")
+	l.md.keepaliveInterval = mdutil.GetDuration(md, "keepalive.interval")
+	l.md.keepaliveCount = mdutil.GetInt(md, "keepalive.count")
 	return
 }

listener/mtls/listener.go

@@ -64,6 +64,16 @@ func (l *mtlsListener) Init(md md.Metadata) (err error) {
 	if err != nil {
 		return
 	}
+	if l.md.keepalive {
+		ln = xnet.WrapKeepaliveListener(ln, net.KeepAliveConfig{
+			Enable:   true,
+			Idle:     l.md.keepaliveIdle,
+			Interval: l.md.keepaliveInterval,
+			Count:    l.md.keepaliveCount,
+		})
+		l.logger.Debugf("tcp keepalive enabled: idle=%v interval=%v count=%d",
+			l.md.keepaliveIdle, l.md.keepaliveInterval, l.md.keepaliveCount)
+	}
 
 	ln = proxyproto.WrapListener(l.options.ProxyProtocol, ln, 10*time.Second)
 	ln = metrics.WrapListener(l.options.Service, ln)

listener/mtls/metadata.go

@@ -1,6 +1,8 @@
 package mtls
 
 import (
+	"time"
+
 	mdata "github.com/go-gost/core/metadata"
 	"github.com/go-gost/x/internal/util/mux"
 	mdutil "github.com/go-gost/x/metadata/util"
@@ -11,9 +13,13 @@ const (
 )
 
 type metadata struct {
-	muxCfg  *mux.Config
+	muxCfg            *mux.Config
-	backlog int
+	backlog           int
-	mptcp   bool
+	mptcp             bool
+	keepalive         bool
+	keepaliveIdle     time.Duration
+	keepaliveInterval time.Duration
+	keepaliveCount    int
 }
 
 func (l *mtlsListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -32,6 +38,9 @@ func (l *mtlsListener) parseMetadata(md mdata.Metadata) (err error) {
 		MaxStreamBuffer:   mdutil.GetInt(md, "mux.maxStreamBuffer"),
 	}
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
-
+	l.md.keepalive = mdutil.GetBool(md, "keepalive")
+	l.md.keepaliveIdle = mdutil.GetDuration(md, "keepalive.idle")
+	l.md.keepaliveInterval = mdutil.GetDuration(md, "keepalive.interval")
+	l.md.keepaliveCount = mdutil.GetInt(md, "keepalive.count")
 	return
 }

listener/mws/listener.go

@@ -109,6 +109,16 @@ func (l *mwsListener) Init(md md.Metadata) (err error) {
 	if err != nil {
 		return
 	}
+	if l.md.keepalive {
+		ln = xnet.WrapKeepaliveListener(ln, net.KeepAliveConfig{
+			Enable:   true,
+			Idle:     l.md.keepaliveIdle,
+			Interval: l.md.keepaliveInterval,
+			Count:    l.md.keepaliveCount,
+		})
+		l.log.Debugf("tcp keepalive enabled: idle=%v interval=%v count=%d",
+			l.md.keepaliveIdle, l.md.keepaliveInterval, l.md.keepaliveCount)
+	}
 	ln = proxyproto.WrapListener(l.options.ProxyProtocol, ln, 10*time.Second)
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)

listener/mws/metadata.go

@@ -28,6 +28,11 @@ type metadata struct {
 	muxCfg *mux.Config
 
 	mptcp bool
+
+	keepalive         bool
+	keepaliveIdle     time.Duration
+	keepaliveInterval time.Duration
+	keepaliveCount    int
 }
 
 func (l *mwsListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -67,5 +72,10 @@ func (l *mwsListener) parseMetadata(md mdata.Metadata) (err error) {
 
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
+	l.md.keepalive = mdutil.GetBool(md, "keepalive")
+	l.md.keepaliveIdle = mdutil.GetDuration(md, "keepalive.idle")
+	l.md.keepaliveInterval = mdutil.GetDuration(md, "keepalive.interval")
+	l.md.keepaliveCount = mdutil.GetInt(md, "keepalive.count")
+
 	return
 }

listener/ssh/listener.go

@@ -66,6 +66,16 @@ func (l *sshListener) Init(md md.Metadata) (err error) {
 	if err != nil {
 		return err
 	}
+	if l.md.keepalive {
+		ln = xnet.WrapKeepaliveListener(ln, net.KeepAliveConfig{
+			Enable:   true,
+			Idle:     l.md.keepaliveIdle,
+			Interval: l.md.keepaliveInterval,
+			Count:    l.md.keepaliveCount,
+		})
+		l.logger.Debugf("tcp keepalive enabled: idle=%v interval=%v count=%d",
+			l.md.keepaliveIdle, l.md.keepaliveInterval, l.md.keepaliveCount)
+	}
 
 	ln = proxyproto.WrapListener(l.options.ProxyProtocol, ln, 10*time.Second)
 	ln = metrics.WrapListener(l.options.Service, ln)

listener/ssh/metadata.go

@@ -2,6 +2,7 @@ package ssh
 
 import (
 	"os"
+	"time"
 
 	mdata "github.com/go-gost/core/metadata"
 	ssh_util "github.com/go-gost/x/internal/util/ssh"
@@ -19,6 +20,11 @@ type metadata struct {
 	authorizedKeys map[string]bool
 	backlog        int
 	mptcp          bool
+
+	keepalive         bool
+	keepaliveIdle     time.Duration
+	keepaliveInterval time.Duration
+	keepaliveCount    int
 }
 
 func (l *sshListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -72,5 +78,10 @@ func (l *sshListener) parseMetadata(md mdata.Metadata) (err error) {
 
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
+	l.md.keepalive = mdutil.GetBool(md, "keepalive")
+	l.md.keepaliveIdle = mdutil.GetDuration(md, "keepalive.idle")
+	l.md.keepaliveInterval = mdutil.GetDuration(md, "keepalive.interval")
+	l.md.keepaliveCount = mdutil.GetInt(md, "keepalive.count")
+
 	return
 }

listener/sshd/listener.go

@@ -74,6 +74,16 @@ func (l *sshdListener) Init(md md.Metadata) (err error) {
 	if err != nil {
 		return err
 	}
+	if l.md.keepalive {
+		ln = xnet.WrapKeepaliveListener(ln, net.KeepAliveConfig{
+			Enable:   true,
+			Idle:     l.md.keepaliveIdle,
+			Interval: l.md.keepaliveInterval,
+			Count:    l.md.keepaliveCount,
+		})
+		l.logger.Debugf("tcp keepalive enabled: idle=%v interval=%v count=%d",
+			l.md.keepaliveIdle, l.md.keepaliveInterval, l.md.keepaliveCount)
+	}
 
 	ln = proxyproto.WrapListener(l.options.ProxyProtocol, ln, 10*time.Second)
 	ln = metrics.WrapListener(l.options.Service, ln)

listener/sshd/metadata.go

@@ -3,6 +3,7 @@ package ssh
 import (
 	"fmt"
 	"os"
+	"time"
 
 	mdata "github.com/go-gost/core/metadata"
 	ssh_util "github.com/go-gost/x/internal/util/ssh"
@@ -21,6 +22,11 @@ type metadata struct {
 	authorizedKeys map[string]bool
 	backlog        int
 	mptcp          bool
+
+	keepalive         bool
+	keepaliveIdle     time.Duration
+	keepaliveInterval time.Duration
+	keepaliveCount    int
 }
 
 func (l *sshdListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -82,5 +88,10 @@ func (l *sshdListener) parseMetadata(md mdata.Metadata) (err error) {
 
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
+	l.md.keepalive = mdutil.GetBool(md, "keepalive")
+	l.md.keepaliveIdle = mdutil.GetDuration(md, "keepalive.idle")
+	l.md.keepaliveInterval = mdutil.GetDuration(md, "keepalive.interval")
+	l.md.keepaliveCount = mdutil.GetInt(md, "keepalive.count")
+
 	return
 }

listener/tcp/listener.go

@@ -62,7 +62,7 @@ func (l *tcpListener) Init(md md.Metadata) (err error) {
 	}
 
 	if l.md.keepalive {
-		ln = newKeepaliveListener(ln, net.KeepAliveConfig{
+		ln = xnet.WrapKeepaliveListener(ln, net.KeepAliveConfig{
 			Enable:   true,
 			Idle:     l.md.keepaliveIdle,
 			Interval: l.md.keepaliveInterval,
@@ -112,24 +112,3 @@ func (l *tcpListener) Close() error {
 	return l.ln.Close()
 }
 
-// keepaliveListener applies TCP keepalive settings to every accepted connection
-// before the connection enters the middleware chain.
-type keepaliveListener struct {
-	net.Listener
-	cfg net.KeepAliveConfig
-}
-
-func newKeepaliveListener(ln net.Listener, cfg net.KeepAliveConfig) net.Listener {
-	return &keepaliveListener{Listener: ln, cfg: cfg}
-}
-
-func (l *keepaliveListener) Accept() (net.Conn, error) {
-	conn, err := l.Listener.Accept()
-	if err != nil {
-		return nil, err
-	}
-	if tc, ok := conn.(*net.TCPConn); ok {
-		tc.SetKeepAliveConfig(l.cfg)
-	}
-	return conn, nil
-}

listener/tls/listener.go

@@ -61,6 +61,16 @@ func (l *tlsListener) Init(md md.Metadata) (err error) {
 	if err != nil {
 		return
 	}
+	if l.md.keepalive {
+		ln = xnet.WrapKeepaliveListener(ln, net.KeepAliveConfig{
+			Enable:   true,
+			Idle:     l.md.keepaliveIdle,
+			Interval: l.md.keepaliveInterval,
+			Count:    l.md.keepaliveCount,
+		})
+		l.logger.Debugf("tcp keepalive enabled: idle=%v interval=%v count=%d",
+			l.md.keepaliveIdle, l.md.keepaliveInterval, l.md.keepaliveCount)
+	}
 	ln = proxyproto.WrapListener(l.options.ProxyProtocol, ln, 10*time.Second)
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)

listener/tls/metadata.go

@@ -1,16 +1,25 @@
 package tls
 
 import (
+	"time"
+
 	mdata "github.com/go-gost/core/metadata"
 	mdutil "github.com/go-gost/x/metadata/util"
 )
 
 type metadata struct {
-	mptcp bool
+	mptcp             bool
+	keepalive         bool
+	keepaliveIdle     time.Duration
+	keepaliveInterval time.Duration
+	keepaliveCount    int
 }
 
 func (l *tlsListener) parseMetadata(md mdata.Metadata) (err error) {
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
-
+	l.md.keepalive = mdutil.GetBool(md, "keepalive")
+	l.md.keepaliveIdle = mdutil.GetDuration(md, "keepalive.idle")
+	l.md.keepaliveInterval = mdutil.GetDuration(md, "keepalive.interval")
+	l.md.keepaliveCount = mdutil.GetInt(md, "keepalive.count")
 	return
 }

listener/ws/listener.go

@@ -104,6 +104,16 @@ func (l *wsListener) Init(md md.Metadata) (err error) {
 	if err != nil {
 		return
 	}
+	if l.md.keepalive {
+		ln = xnet.WrapKeepaliveListener(ln, net.KeepAliveConfig{
+			Enable:   true,
+			Idle:     l.md.keepaliveIdle,
+			Interval: l.md.keepaliveInterval,
+			Count:    l.md.keepaliveCount,
+		})
+		l.log.Debugf("tcp keepalive enabled: idle=%v interval=%v count=%d",
+			l.md.keepaliveIdle, l.md.keepaliveInterval, l.md.keepaliveCount)
+	}
 	ln = proxyproto.WrapListener(l.options.ProxyProtocol, ln, 10*time.Second)
 	ln = metrics.WrapListener(l.options.Service, ln)
 	ln = stats.WrapListener(ln, l.options.Stats)

listener/ws/metadata.go

@@ -25,6 +25,11 @@ type metadata struct {
 	header            http.Header
 
 	mptcp bool
+
+	keepalive         bool
+	keepaliveIdle     time.Duration
+	keepaliveInterval time.Duration
+	keepaliveCount    int
 }
 
 func (l *wsListener) parseMetadata(md mdata.Metadata) (err error) {
@@ -54,5 +59,10 @@ func (l *wsListener) parseMetadata(md mdata.Metadata) (err error) {
 
 	l.md.mptcp = mdutil.GetBool(md, "mptcp")
 
+	l.md.keepalive = mdutil.GetBool(md, "keepalive")
+	l.md.keepaliveIdle = mdutil.GetDuration(md, "keepalive.idle")
+	l.md.keepaliveInterval = mdutil.GetDuration(md, "keepalive.interval")
+	l.md.keepaliveCount = mdutil.GetInt(md, "keepalive.count")
+
 	return
 }