chore: better apply tcp keepalive to listeners

component/keepalive/tcp_keepalive.go

@@ -0,0 +1,65 @@
+package keepalive
+
+import (
+	"net"
+	"runtime"
+	"time"
+
+	"github.com/metacubex/mihomo/common/atomic"
+	"github.com/metacubex/mihomo/common/utils"
+)
+
+var (
+	keepAliveIdle     = atomic.NewTypedValue[time.Duration](0 * time.Second)
+	keepAliveInterval = atomic.NewTypedValue[time.Duration](0 * time.Second)
+	disableKeepAlive  = atomic.NewBool(false)
+
+	SetDisableKeepAliveCallback = utils.NewCallback[bool]()
+)
+
+func SetKeepAliveIdle(t time.Duration) {
+	keepAliveIdle.Store(t)
+}
+
+func SetKeepAliveInterval(t time.Duration) {
+	keepAliveInterval.Store(t)
+}
+
+func KeepAliveIdle() time.Duration {
+	return keepAliveIdle.Load()
+}
+
+func KeepAliveInterval() time.Duration {
+	return keepAliveInterval.Load()
+}
+
+func SetDisableKeepAlive(disable bool) {
+	if runtime.GOOS == "android" {
+		setDisableKeepAlive(false)
+	} else {
+		setDisableKeepAlive(disable)
+	}
+}
+
+func setDisableKeepAlive(disable bool) {
+	disableKeepAlive.Store(disable)
+	SetDisableKeepAliveCallback.Emit(disable)
+}
+
+func DisableKeepAlive() bool {
+	return disableKeepAlive.Load()
+}
+
+func SetNetDialer(dialer *net.Dialer) {
+	setNetDialer(dialer)
+}
+
+func SetNetListenConfig(lc *net.ListenConfig) {
+	setNetListenConfig(lc)
+}
+
+func TCPKeepAlive(c net.Conn) {
+	if tcp, ok := c.(*net.TCPConn); ok && tcp != nil {
+		tcpKeepAlive(tcp)
+	}
+}

component/keepalive/tcp_keepalive_go122.go

@@ -0,0 +1,30 @@
+//go:build !go1.23
+
+package keepalive
+
+import "net"
+
+func tcpKeepAlive(tcp *net.TCPConn) {
+	if DisableKeepAlive() {
+		_ = tcp.SetKeepAlive(false)
+	} else {
+		_ = tcp.SetKeepAlive(true)
+		_ = tcp.SetKeepAlivePeriod(KeepAliveInterval())
+	}
+}
+
+func setNetDialer(dialer *net.Dialer) {
+	if DisableKeepAlive() {
+		dialer.KeepAlive = -1 // If negative, keep-alive probes are disabled.
+	} else {
+		dialer.KeepAlive = KeepAliveInterval()
+	}
+}
+
+func setNetListenConfig(lc *net.ListenConfig) {
+	if DisableKeepAlive() {
+		lc.KeepAlive = -1 // If negative, keep-alive probes are disabled.
+	} else {
+		lc.KeepAlive = KeepAliveInterval()
+	}
+}

component/keepalive/tcp_keepalive_go123.go

@@ -0,0 +1,45 @@
+//go:build go1.23
+
+package keepalive
+
+import "net"
+
+func keepAliveConfig() net.KeepAliveConfig {
+	config := net.KeepAliveConfig{
+		Enable:   true,
+		Idle:     KeepAliveIdle(),
+		Interval: KeepAliveInterval(),
+	}
+	if !SupportTCPKeepAliveCount() {
+		// it's recommended to set both Idle and Interval to non-negative values in conjunction with a -1
+		// for Count on those old Windows if you intend to customize the TCP keep-alive settings.
+		config.Count = -1
+	}
+	return config
+}
+
+func tcpKeepAlive(tcp *net.TCPConn) {
+	if DisableKeepAlive() {
+		_ = tcp.SetKeepAlive(false)
+	} else {
+		_ = tcp.SetKeepAliveConfig(keepAliveConfig())
+	}
+}
+
+func setNetDialer(dialer *net.Dialer) {
+	if DisableKeepAlive() {
+		dialer.KeepAlive = -1 // If negative, keep-alive probes are disabled.
+		dialer.KeepAliveConfig.Enable = false
+	} else {
+		dialer.KeepAliveConfig = keepAliveConfig()
+	}
+}
+
+func setNetListenConfig(lc *net.ListenConfig) {
+	if DisableKeepAlive() {
+		lc.KeepAlive = -1 // If negative, keep-alive probes are disabled.
+		lc.KeepAliveConfig.Enable = false
+	} else {
+		lc.KeepAliveConfig = keepAliveConfig()
+	}
+}

component/keepalive/tcp_keepalive_go123_unix.go

@@ -0,0 +1,15 @@
+//go:build go1.23 && unix
+
+package keepalive
+
+func SupportTCPKeepAliveIdle() bool {
+	return true
+}
+
+func SupportTCPKeepAliveInterval() bool {
+	return true
+}
+
+func SupportTCPKeepAliveCount() bool {
+	return true
+}

component/keepalive/tcp_keepalive_go123_windows.go

@@ -0,0 +1,63 @@
+//go:build go1.23 && windows
+
+// copy and modify from golang1.23's internal/syscall/windows/version_windows.go
+
+package keepalive
+
+import (
+	"errors"
+	"sync"
+	"syscall"
+
+	"github.com/metacubex/mihomo/constant/features"
+
+	"golang.org/x/sys/windows"
+)
+
+var (
+	supportTCPKeepAliveIdle     bool
+	supportTCPKeepAliveInterval bool
+	supportTCPKeepAliveCount    bool
+)
+
+var initTCPKeepAlive = sync.OnceFunc(func() {
+	s, err := windows.WSASocket(syscall.AF_INET, syscall.SOCK_STREAM, syscall.IPPROTO_TCP, nil, 0, windows.WSA_FLAG_NO_HANDLE_INHERIT)
+	if err != nil {
+		// Fallback to checking the Windows version.
+		major, build := features.WindowsMajorVersion, features.WindowsBuildNumber
+		supportTCPKeepAliveIdle = major >= 10 && build >= 16299
+		supportTCPKeepAliveInterval = major >= 10 && build >= 16299
+		supportTCPKeepAliveCount = major >= 10 && build >= 15063
+		return
+	}
+	defer windows.Closesocket(s)
+	var optSupported = func(opt int) bool {
+		err := windows.SetsockoptInt(s, syscall.IPPROTO_TCP, opt, 1)
+		return !errors.Is(err, syscall.WSAENOPROTOOPT)
+	}
+	supportTCPKeepAliveIdle = optSupported(windows.TCP_KEEPIDLE)
+	supportTCPKeepAliveInterval = optSupported(windows.TCP_KEEPINTVL)
+	supportTCPKeepAliveCount = optSupported(windows.TCP_KEEPCNT)
+})
+
+// SupportTCPKeepAliveIdle indicates whether TCP_KEEPIDLE is supported.
+// The minimal requirement is Windows 10.0.16299.
+func SupportTCPKeepAliveIdle() bool {
+	initTCPKeepAlive()
+	return supportTCPKeepAliveIdle
+}
+
+// SupportTCPKeepAliveInterval indicates whether TCP_KEEPINTVL is supported.
+// The minimal requirement is Windows 10.0.16299.
+func SupportTCPKeepAliveInterval() bool {
+	initTCPKeepAlive()
+	return supportTCPKeepAliveInterval
+}
+
+// SupportTCPKeepAliveCount indicates whether TCP_KEEPCNT is supported.
+// supports TCP_KEEPCNT.
+// The minimal requirement is Windows 10.0.15063.
+func SupportTCPKeepAliveCount() bool {
+	initTCPKeepAlive()
+	return supportTCPKeepAliveCount
+}