From bf39ca608f080a3e06f98f3f1ad0868685410b35 Mon Sep 17 00:00:00 2001 From: Afloat Date: Fri, 20 Nov 2026 14:47:10 +0800 Subject: [PATCH] fix: keep listen retries within the valid port range --- src/listen-policy.ts | 9 +++- src/port-owner.ts | 3 +- tests/listen-retry-boundary.test.ts | 65 +++++++++++++++++++++++++++++ 3 files changed, 75 insertions(+), 2 deletions(-) create mode 100644 tests/listen-retry-boundary.test.ts diff --git a/src/listen-policy.ts b/src/listen-policy.ts index ac11fe0e87..b08e054bfa 100644 --- a/src/listen-policy.ts +++ b/src/listen-policy.ts @@ -67,6 +67,13 @@ export interface EaddrinuseContext { lastTriedPort: number; } +/** Use the existing ephemeral fallback when either the retry budget or the + * valid numeric port range is exhausted. Both pre- and post-bind retries + * must avoid handing 65536 to Node's listener. */ +export function nextListenPort(port: number, nextAttempt: number, maxAttempts: number): number { + return nextAttempt >= maxAttempts || port >= 65535 ? 0 : port + 1; +} + export function decideEaddrinuse(ctx: EaddrinuseContext): EaddrinuseAction { // The twin rule outranks everything else: a healthy peer already serves // real traffic on that port, so no wait/ladder variant may touch it — the @@ -89,7 +96,7 @@ export function decideEaddrinuse(ctx: EaddrinuseContext): EaddrinuseAction { return { kind: "wait-predecessor", port: ctx.lastTriedPort }; } const nextAttempts = ctx.attempts + 1; - return { kind: "ladder", nextPort: nextAttempts === ctx.maxAttempts ? 0 : ctx.lastTriedPort + 1 }; + return { kind: "ladder", nextPort: nextListenPort(ctx.lastTriedPort, nextAttempts, ctx.maxAttempts) }; } /** #3044/#2941: ladder rights for the POST-BIND claim check (port-owner's diff --git a/src/port-owner.ts b/src/port-owner.ts index 436ddeefa0..1c881427fd 100644 --- a/src/port-owner.ts +++ b/src/port-owner.ts @@ -1,4 +1,5 @@ import { isProxyInstanceFile, type ProxyInstanceFile } from "./instance.js"; +import { nextListenPort } from "./listen-policy.js"; /** #2941: post-bind port-ownership verification + pointer-clobber guard for * same-lane double-spawn residuals (#707 follow-ups). Conservative by @@ -170,7 +171,7 @@ export async function resolvePortClaim(params: { return { kind: "die", message: `port ${portOf(params.origin)} is shared with ${who} — refusing to serve a contested port (#2941)` }; } const attempts = params.listenAttempts + 1; - const nextPort = attempts >= params.maxListenAttempts ? 0 : portOf(params.origin) + 1; + const nextPort = nextListenPort(portOf(params.origin), attempts, params.maxListenAttempts); return { kind: "ladder", nextPort, foreign }; } diff --git a/tests/listen-retry-boundary.test.ts b/tests/listen-retry-boundary.test.ts new file mode 100644 index 0000000000..c49f9c416e --- /dev/null +++ b/tests/listen-retry-boundary.test.ts @@ -0,0 +1,65 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { createServer } from "node:net"; +import { resolveZonePortBase } from "../src/config.ts"; +import { decideEaddrinuse, type EaddrinuseContext } from "../src/listen-policy.ts"; +import { resolvePortClaim } from "../src/port-owner.ts"; + +const base: EaddrinuseContext = { + upgradeReplacement: false, twinHolds: false, newerHolderHolds: false, + launchToken: true, strictPort: false, attempts: 0, maxAttempts: 17, + predecessorTicksLeft: 10, predecessorHolds: false, + lastTriedPort: resolveZonePortBase({ BILI_ZONE_PORT: "65535" }), +}; + +async function bindRetry(port: number): Promise { + const server = createServer(); + try { + // Exercise what the listener does with the decision. The old boundary result is + // 65536, which throws ERR_SOCKET_BAD_PORT before a listen event can be emitted. + await new Promise((resolve, reject) => { + server.once("error", reject); + server.listen(port, "127.0.0.1", resolve); + }); + const address = server.address(); + assert.ok(address && typeof address === "object" && address.port > 0 && address.port <= 65535); + assert.equal(port, 0, "the OS chooses a free port when the numeric ladder is exhausted"); + } finally { + if (server.listening) await new Promise((resolve, reject) => server.close(error => error ? reject(error) : resolve())); + } +} + +async function foreignClaim(port: number, canLadder = true) { + return resolvePortClaim({ + origin: `http://127.0.0.1:${port}`, ownPid: 100, canLadder, + listenAttempts: 0, maxListenAttempts: 17, + probe: { fetchImpl: async () => ({ ok: true, json: async () => ({ ok: true, pid: 200 }) }) }, + }); +} + +test("a busy highest valid zone port retries on a bindable ephemeral port", async () => { + assert.equal(base.lastTriedPort, 65535, "the configured zone boundary is valid"); + const action = decideEaddrinuse(base); + assert.equal(action.kind, "ladder"); + if (action.kind === "ladder") await bindRetry(action.nextPort); +}); + +test("post-bind foreign ownership at the port boundary retries on a bindable ephemeral port", async () => { + const action = await foreignClaim(65535); + assert.equal(action.kind, "ladder"); + if (action.kind === "ladder") await bindRetry(action.nextPort); +}); + +test("both retry paths still try the last valid numeric port before using an ephemeral port", async () => { + assert.deepEqual(decideEaddrinuse({ ...base, lastTriedPort: 65534 }), { kind: "ladder", nextPort: 65535 }); + const action = await foreignClaim(65534); + assert.equal(action.kind === "ladder" ? action.nextPort : undefined, 65535); +}); + +test("the numeric boundary does not grant retry rights or bypass a predecessor wait", async () => { + assert.deepEqual(decideEaddrinuse({ ...base, strictPort: true }), { kind: "fail-fast", reason: "strict-port" }); + assert.deepEqual(decideEaddrinuse({ ...base, launchToken: false }), { kind: "fail-fast", reason: "port-busy" }); + assert.deepEqual(decideEaddrinuse({ ...base, upgradeReplacement: true }), { kind: "fail-fast", reason: "upgrade-replacement" }); + assert.deepEqual(decideEaddrinuse({ ...base, predecessorHolds: true }), { kind: "wait-predecessor", port: 65535 }); + assert.equal((await foreignClaim(65535, false)).kind, "die"); +});