From 6b08f615ddd3f50c1a632277bb9e24373615309f Mon Sep 17 00:00:00 2001 From: Afloat Date: Tue, 17 Nov 2026 11:32:03 +0800 Subject: [PATCH] fix: close pending WebSocket upgrades during server shutdown --- src/ws-bridge.ts | 21 ++++++- tests/ws-bridge-pending-close.test.ts | 91 +++++++++++++++++++++++++++ 2 files changed, 111 insertions(+), 1 deletion(-) create mode 100644 tests/ws-bridge-pending-close.test.ts diff --git a/src/ws-bridge.ts b/src/ws-bridge.ts index 2b5debf985..a2e60ea92f 100644 --- a/src/ws-bridge.ts +++ b/src/ws-bridge.ts @@ -93,9 +93,17 @@ export function installWebSocketBridge( ): (req: http.IncomingMessage, socket: Duplex, head: Buffer) => boolean { const wss = new WebSocketServer({ noServer: true, maxPayload: limitsReceiveBytes(), perMessageDeflate: false }); const sessions = new Set<{ session: WsBridgeSession; peer: WebSocket }>(); + const pendingUpgrades = new Set(); + let closing = false; + const stopPendingUpgrades = (): void => { + closing = true; + for (const socket of pendingUpgrades) socket.destroy(); + pendingUpgrades.clear(); + }; let connectionId = 0; const close = server.close.bind(server); server.close = callback => { + stopPendingUpgrades(); const live = [...sessions]; sessions.clear(); // exactly-once: the 'close' event backstop below must not re-run for (const { session } of live) session.shutdown("server-close"); @@ -103,6 +111,7 @@ export function installWebSocketBridge( return close(callback); }; server.on("close", () => { + stopPendingUpgrades(); for (const { session } of sessions) session.shutdown("server-close"); for (const peer of wss.clients) peer.terminate(); wss.close(); @@ -118,7 +127,14 @@ export function installWebSocketBridge( return upstream === undefined ? [] : [{ codec: candidate, upstream, conversationId }]; })[0] : undefined; if (!claim) return false; + if (closing) { socket.destroy(); return true; } const { codec, upstream, conversationId } = claim; + // HTTP has already handed this socket to the upgrade listener, but it + // is not a WebSocket client until async destination admission finishes. + // Keep it in the shutdown set throughout that gap, including DNS waits. + pendingUpgrades.add(socket); + const forgetPending = (): void => { pendingUpgrades.delete(socket); }; + socket.once("close", forgetPending); // Stamp the codec name onto the upgrade request BEFORE the session is // created: codecs rebuild in-process HTTP envelopes from `source`, so // every envelope inherits this marker and the request pipeline can tell @@ -128,11 +144,11 @@ export function installWebSocketBridge( source.headers["x-bili-ws-lane"] = codec.name; void (async () => { const verdict = await checkTunnelDestination(upstream, { selfPort: source.socket.localPort, clientLoopback: true, allowlist: tunnelAllowlistFromEnv(), egressProxied: isEgressProxied?.(upstream) }); + if (closing || socket.destroyed) return; if (!verdict.ok) { socket.end("HTTP/1.1 403 Forbidden\r\nConnection: close\r\nContent-Length: 0\r\n\r\n"); return; } - if (socket.destroyed) return; wss.handleUpgrade(source, socket, head, peer => { const label = `[${codec.name}] [conn=${++connectionId}] [session=${JSON.stringify(conversationId.slice(0, 128))}]`; const trace: WsBridgeLog = (level, message) => log(level, `${label} ${message}`); @@ -149,6 +165,9 @@ export function installWebSocketBridge( })().catch(() => { log("warn", `[${codec.name}] upgrade failed`); if (!socket.destroyed) socket.end("HTTP/1.1 502 Bad Gateway\r\nConnection: close\r\nContent-Length: 0\r\n\r\n"); + }).finally(() => { + forgetPending(); + socket.off("close", forgetPending); }); return true; }; diff --git a/tests/ws-bridge-pending-close.test.ts b/tests/ws-bridge-pending-close.test.ts new file mode 100644 index 0000000000..05ab031718 --- /dev/null +++ b/tests/ws-bridge-pending-close.test.ts @@ -0,0 +1,91 @@ +import assert from "node:assert/strict"; +import dns from "node:dns/promises"; +import { once } from "node:events"; +import http from "node:http"; +import { syncBuiltinESMExports } from "node:module"; +import test from "node:test"; +import { setTimeout as delay } from "node:timers/promises"; +import { WebSocket } from "ws"; +import { installWebSocketBridge, type WsBridgeCodec } from "../src/ws-bridge.ts"; + +const headers = { "x-bili-plugin": "close-fixture", "x-bili-plugin-conversation": "pending-close" }; + +function fixture(proxied: boolean) { + const server = http.createServer((_req, res) => res.writeHead(404).end()); + let created = 0; + const codec: WsBridgeCodec = { + name: "close-fixture", pluginMarker: "close-fixture", + matchUpgrade: () => "https://pending-admission.example/echo", + createSession: () => { + created++; + return { onMessage() {}, onClose() {}, shutdown() {} }; + }, + }; + const handler = installWebSocketBridge(server, async () => {}, () => {}, [codec], () => proxied); + return { server, handler, created: () => created }; +} + +test("server close does not admit a WebSocket whose destination check has not settled", async () => { + const { server, handler, created } = fixture(true); + let closed = Promise.resolve(); + server.on("upgrade", (request, socket, head) => { + assert.equal(handler(request, socket, head), true); + closed = new Promise((resolve) => server.close(() => resolve())); + }); + await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve)); + const address = server.address(); + assert.ok(address && typeof address !== "string"); + const peer = new WebSocket(`ws://127.0.0.1:${address.port}/bridge`, { headers }); + const peerClosed = new Promise((resolve) => peer.on("close", () => resolve())); + peer.on("error", () => {}); + try { + const outcome = await Promise.race([ + new Promise((resolve) => peer.on("open", () => resolve("opened"))), + peerClosed.then(() => "closed"), + ]); + assert.equal(outcome, "closed", "shutdown must not create a session after its teardown pass"); + await closed; + assert.equal(created(), 0); + } finally { + peer.terminate(); + await peerClosed; + await closed; + } +}); + +test("server close releases an upgrade socket without waiting for DNS admission", async (t) => { + const lookupEntered = Promise.withResolvers(); + const lookupReleased = Promise.withResolvers>(); + const lookup = t.mock.method(dns, "lookup", async () => { + lookupEntered.resolve(); + return lookupReleased.promise; + }); + syncBuiltinESMExports(); + const { server, handler, created } = fixture(false); + server.on("upgrade", (request, socket, head) => { assert.equal(handler(request, socket, head), true); }); + await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve)); + const address = server.address(); + assert.ok(address && typeof address !== "string"); + const peer = new WebSocket(`ws://127.0.0.1:${address.port}/bridge`, { headers }); + const peerClosed = new Promise((resolve) => peer.on("close", () => resolve())); + peer.on("error", () => {}); + let closed: Promise | undefined; + try { + await lookupEntered.promise; + closed = new Promise((resolve) => server.close(() => resolve())); + const outcome = await Promise.race([closed.then(() => "closed"), delay(500).then(() => "still waiting for DNS")]); + assert.equal(outcome, "closed"); + await peerClosed; + lookupReleased.resolve([{ address: "203.0.113.1", family: 4 }]); + await delay(0); + assert.equal(created(), 0, "a late successful DNS answer cannot revive the upgrade"); + } finally { + lookupReleased.resolve([]); + lookup.mock.restore(); + syncBuiltinESMExports(); + peer.terminate(); + await peerClosed; + if (closed) await closed; + else { server.close(); await once(server, "close"); } + } +});