From 6c1442aaf9bf8a68deac046dffcc36968427d8ac Mon Sep 17 00:00:00 2001 From: wizardchen Date: Tue, 5 May 2026 00:33:10 +0800 Subject: [PATCH] =?UTF-8?q?fix(im):=20clamp=20reconnect=20backoff=20to=20a?= =?UTF-8?q?void=20int64=20overflow=20=E2=86=92=20busy=20loop?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit After ~34 failed reconnects, math.Pow(2, attempt-1) * baseDelay overflowed int64 and produced a negative time.Duration, which bypassed the max-delay cap. time.After(-1s) fires immediately, so a single bad credential (e.g. WeCom bot_id/secret error 853000) turned into thousands of reconnects per minute and massive log spam ("reconnecting in -1s (attempt 4601)"). Replace math.Pow with a bit-shift and cap the exponent at 30, which is well above the shift needed to reach the 30s max delay. Same fix applied to the WeChat long-poll client. Added a regression test that exercises attempt=4601. Co-Authored-By: Claude Opus 4.7 (1M context) --- internal/im/wechat/longpoll.go | 13 ++++++++-- internal/im/wecom/longconn.go | 14 +++++++++-- internal/im/wecom/reconnect_test.go | 37 +++++++++++++++++++++++++++++ 3 files changed, 60 insertions(+), 4 deletions(-) create mode 100644 internal/im/wecom/reconnect_test.go diff --git a/internal/im/wechat/longpoll.go b/internal/im/wechat/longpoll.go index 76edb4d8..b7358c3b 100644 --- a/internal/im/wechat/longpoll.go +++ b/internal/im/wechat/longpoll.go @@ -16,7 +16,6 @@ import ( "encoding/json" "fmt" "io" - "math" "net/http" "strings" "time" @@ -297,7 +296,17 @@ func (c *LongPollClient) parseMessage(msg *weixinMessage) *im.IncomingMessage { } func pollReconnectDelay(attempt int) time.Duration { - delay := reconnectBaseDelay * time.Duration(math.Pow(2, float64(attempt-1))) + if attempt < 1 { + return reconnectBaseDelay + } + // Cap the exponent to avoid int64 overflow: base (1e9 ns) * 2^shift + // overflows when shift ≥ 34, producing a negative duration that would + // bypass the max-delay check and cause a busy reconnect loop. + shift := attempt - 1 + if shift > 30 { + return reconnectMaxDelay + } + delay := reconnectBaseDelay * (1 << shift) if delay > reconnectMaxDelay { delay = reconnectMaxDelay } diff --git a/internal/im/wecom/longconn.go b/internal/im/wecom/longconn.go index fe202ae5..73350a94 100644 --- a/internal/im/wecom/longconn.go +++ b/internal/im/wecom/longconn.go @@ -15,7 +15,6 @@ import ( "context" "encoding/json" "fmt" - "math" "strings" "sync" "sync/atomic" @@ -772,7 +771,18 @@ func (c *LongConnClient) writeJSON(v interface{}) error { } func reconnectDelay(attempt int) time.Duration { - delay := defaultReconnectBaseDelay * time.Duration(math.Pow(2, float64(attempt-1))) + if attempt < 1 { + return defaultReconnectBaseDelay + } + // Cap the exponent to avoid int64 overflow: base (1e9 ns) * 2^shift + // overflows when shift ≥ 34, producing a negative duration that would + // bypass the max-delay check and cause a busy reconnect loop. + // Any shift ≥ 5 already exceeds the 30s max, so 30 is a safe ceiling. + shift := attempt - 1 + if shift > 30 { + return defaultReconnectMaxDelay + } + delay := defaultReconnectBaseDelay * (1 << shift) if delay > defaultReconnectMaxDelay { delay = defaultReconnectMaxDelay } diff --git a/internal/im/wecom/reconnect_test.go b/internal/im/wecom/reconnect_test.go new file mode 100644 index 00000000..95ee207d --- /dev/null +++ b/internal/im/wecom/reconnect_test.go @@ -0,0 +1,37 @@ +package wecom + +import ( + "testing" + "time" +) + +// TestReconnectDelayOverflow guards against the bug where large attempt +// counters produced a negative time.Duration, bypassing the max-delay +// cap and causing a busy reconnect loop (e.g. "reconnecting in -1s"). +func TestReconnectDelayOverflow(t *testing.T) { + tests := []struct { + name string + attempt int + want time.Duration + }{ + {"zero attempt clamps to base", 0, defaultReconnectBaseDelay}, + {"negative attempt clamps to base", -5, defaultReconnectBaseDelay}, + {"attempt 1 = base", 1, defaultReconnectBaseDelay}, + {"attempt 2 = 2× base", 2, 2 * defaultReconnectBaseDelay}, + {"attempt 5 = 16s", 5, 16 * time.Second}, + {"attempt 6 caps at max", 6, defaultReconnectMaxDelay}, + {"attempt 100 caps at max", 100, defaultReconnectMaxDelay}, + {"attempt 4601 caps at max (regression)", 4601, defaultReconnectMaxDelay}, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got := reconnectDelay(tt.attempt) + if got != tt.want { + t.Errorf("reconnectDelay(%d) = %v, want %v", tt.attempt, got, tt.want) + } + if got <= 0 { + t.Errorf("reconnectDelay(%d) returned non-positive %v — would cause busy loop", tt.attempt, got) + } + }) + } +}