Skip to content
Open
34 changes: 28 additions & 6 deletions src/js/node/http2.ts
Original file line number Diff line number Diff line change
Expand Up @@ -1892,8 +1892,13 @@ interface ClientRequestOptions {
silent?: boolean;
weight?: number;
}
type Socket = import("node:net").Socket & { servername?: undefined; alpnProtocol?: undefined };
type TLSSocket = import("node:tls").TLSSocket;
type Socket = import("node:net").Socket & {
servername?: undefined;
alpnProtocol?: undefined;
secureConnecting?: undefined;
};
// secureConnecting is true from the TCP connect until the TLS handshake completes.
type TLSSocket = import("node:tls").TLSSocket & { secureConnecting?: boolean };

abstract class Http2Session extends EventEmitter {
declare timeout: number | undefined;
Expand Down Expand Up @@ -2550,7 +2555,13 @@ class Http2Stream extends (Duplex as Http2StreamBase) {
// push, regardless of the server-settings default.
const session = this[bunHTTP2Session];
return (
session != null && session.type === 0 && !!session.remoteSettings?.enablePush && !this.destroyed && !this.closed
session != null &&
session.type === 0 &&
!session.closed &&
!session.destroyed &&
!!session.remoteSettings?.enablePush &&
!this.destroyed &&
!this.closed
);
}
close(code?, callback?) {
Expand Down Expand Up @@ -3254,7 +3265,7 @@ class ServerHttp2Stream extends Http2Stream {
}
{
const session = this[bunHTTP2Session];
if (session == null || session.destroyed) {
if (session == null || session.destroyed || session.closed) {
throw $ERR_HTTP2_PUSH_DISABLED();
}
}
Expand Down Expand Up @@ -4634,6 +4645,11 @@ class ServerHttp2Session extends Http2Session {
validateFunction(callback, "callback");

const cb = makeHttp2Ping(callback);
// node cancels a ping issued while connecting or after close().
if (this.connecting || this.closed) {
process.nextTick(cb, $ERR_HTTP2_PING_CANCEL(), 0, payload);
return;
}
const parser = this.#parser;
if (!parser || !this[bunHTTP2Socket]) {
process.nextTick(cb, $ERR_HTTP2_PING_CANCEL(), 0, payload);
Expand Down Expand Up @@ -5502,10 +5518,11 @@ class ClientHttp2Session extends Http2Session {
if (!socket) {
return false;
}
return socket.connecting || false;
// node stays connecting until the TLS handshake completes.
return socket.connecting || socket.secureConnecting || false;
Comment thread
coderabbitai[bot] marked this conversation as resolved.
Resolved
}
get connected() {
return this[bunHTTP2Socket]?.connecting === false;
return this[bunHTTP2Socket] != null && !this.connecting;
}
get destroyed() {
return this[bunHTTP2Socket] === null;
Expand Down Expand Up @@ -5568,6 +5585,11 @@ class ClientHttp2Session extends Http2Session {
validateFunction(callback, "callback");

const cb = makeHttp2Ping(callback);
// node cancels a ping issued while connecting or after close().
if (this.connecting || this.closed) {
Comment thread
claude[bot] marked this conversation as resolved.
Resolved
process.nextTick(cb, $ERR_HTTP2_PING_CANCEL(), 0, payload);
return;
}
const parser = this.#parser;
if (!parser || !this[bunHTTP2Socket]) {
process.nextTick(cb, $ERR_HTTP2_PING_CANCEL(), 0, payload);
Expand Down
167 changes: 167 additions & 0 deletions test/js/node/http2/node-http2-session-close.test.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,167 @@
// What a node:http2 session still accepts after close(), and while it is still connecting.
// node refuses pushStream() and ping() on a closed session, and cancels a ping() issued before
// the session is ready (for https, that is until the TLS handshake completes).
import { expect, it } from "bun:test";
import http2 from "node:http2";
import tls from "node:tls";
import { TLS_CERT, TLS_OPTIONS } from "./http2-helpers";

// Any 'error' on a tracked emitter rejects the awaited promise, so a failed connect or handshake
// reports its cause instead of a timeout.
function errorGuard(...emitters) {
const failure = Promise.withResolvers<never>();
const watch = emitter => emitter.on("error", failure.reject);
for (const emitter of emitters) watch(emitter);
const settled = <T>(promise: Promise<T>) => Promise.race([promise, failure.promise]);
return { watch, settled };
}

it("http2 pushStream() and ping() are refused after session.close(), like node", async () => {
const out = {};
const serverDone = Promise.withResolvers();
const server = http2.createServer();
server.on("stream", stream => {
stream.on("error", () => {});
const session = stream.session;
out.pushAllowedBefore = stream.pushAllowed;
session.close();
out.sessionClosed = session.closed;
out.sessionDestroyed = session.destroyed;
out.pushAllowedAfter = stream.pushAllowed;
try {
stream.pushStream({ ":path": "/pushed" }, (err, pushed) => {
out.pushCallback = err ? err.code : "pushed";
if (pushed) {
pushed.on("error", () => {});
pushed.respond({ ":status": 200 });
pushed.end();
}
});
out.pushStream = "no throw";
} catch (e) {
out.pushStream = e.code;
}
// node checks pushAllowed before it validates the callback.
try {
stream.pushStream({ ":path": "/pushed" });
out.pushStreamNoCallback = "no throw";
} catch (e) {
out.pushStreamNoCallback = e.code;
}
out.pingReturn = session.ping((err, duration) => {
out.pingCallback = err ? err.code : "ok";
out.pingDuration = duration;
serverDone.resolve();
});
out.pingCallbackRanSync = "pingCallback" in out;
stream.respond({ ":status": 200 });
stream.end("ok");
});
await new Promise(resolve => server.listen(0, "127.0.0.1", resolve));
const client = http2.connect(`http://127.0.0.1:${server.address().port}`);
try {
const clientClosed = new Promise(resolve => client.once("close", resolve));
Comment thread
robobun marked this conversation as resolved.
Resolved
client.on("stream", (pushed, headers) => {
out.clientGotPush = headers[":path"];
pushed.on("error", () => {});
pushed.resume();
});
const req = client.request({ ":path": "/" });
const { settled } = errorGuard(client, req);
req.resume();
await settled(new Promise(resolve => req.once("close", resolve)));
await settled(serverDone.promise);
await settled(clientClosed);
} finally {
client.destroy();
server.close();
}

expect(out).toEqual({
pushAllowedBefore: true,
sessionClosed: true,
sessionDestroyed: false,
pushAllowedAfter: false,
pushStream: "ERR_HTTP2_PUSH_DISABLED",
pushStreamNoCallback: "ERR_HTTP2_PUSH_DISABLED",
pingReturn: undefined,
pingCallbackRanSync: false,
pingCallback: "ERR_HTTP2_PING_CANCEL",
pingDuration: undefined,
});
});

it("http2 client ping() after session.close() is cancelled on the next tick, like node", async () => {
const server = http2.createServer();
const serverStream = Promise.withResolvers();
server.on("stream", stream => {
stream.on("error", () => {});
serverStream.resolve(stream);
});
await new Promise(resolve => server.listen(0, "127.0.0.1", resolve));
const client = http2.connect(`http://127.0.0.1:${server.address().port}`);
try {
const clientClosed = new Promise(resolve => client.once("close", resolve));
const { watch, settled } = errorGuard(client);
await settled(new Promise(resolve => client.once("connect", resolve)));
const req = client.request({ ":path": "/" });
watch(req);
req.resume();
const stream = await settled(serverStream.promise);

// The open request keeps the session alive, so close() marks it closed without destroying it.
client.close();
expect(client.closed).toBe(true);
expect(client.destroyed).toBe(false);

const pingResult = Promise.withResolvers();
let pingCallbackRan = false;
const pingReturn = client.ping((err, duration) => {
pingCallbackRan = true;
pingResult.resolve({ code: err?.code, duration });
});
expect(pingReturn).toBeUndefined();
// The callback runs on the next tick, never synchronously.
expect(pingCallbackRan).toBe(false);
expect(await settled(pingResult.promise)).toEqual({ code: "ERR_HTTP2_PING_CANCEL", duration: undefined });

stream.respond({ ":status": 200 });
stream.end("ok");
await settled(clientClosed);
} finally {
client.destroy();
server.close();
}
});

it("http2 client ping() during the TLS handshake is cancelled, like node", async () => {
const server = http2.createSecureServer({ cert: TLS_CERT.cert, key: TLS_CERT.key });
await new Promise(resolve => server.listen(0, "127.0.0.1", resolve));
const { port } = server.address();
const socket = tls.connect({ host: "127.0.0.1", port, ALPNProtocols: ["h2"], ...TLS_OPTIONS });
const client = http2.connect(`https://127.0.0.1:${port}`, { createConnection: () => socket });
try {
const { settled } = errorGuard(client, socket);
const connected = new Promise(resolve => client.once("connect", resolve));
// Wait for the TCP connect. The TLS handshake is still in flight.
await settled(new Promise(resolve => socket.once("connect", resolve)));
expect(socket.connecting).toBe(false);
expect(socket.secureConnecting).toBe(true);
expect(client.connecting).toBe(true);

const handshakePing = Promise.withResolvers();
const handshakeReturn = client.ping(err => handshakePing.resolve(err?.code));
expect(handshakeReturn).toBeUndefined();
expect(await settled(handshakePing.promise)).toBe("ERR_HTTP2_PING_CANCEL");

await settled(connected);
expect(client.connecting).toBe(false);
const connectedPing = Promise.withResolvers();
const connectedReturn = client.ping((err, duration) => connectedPing.resolve(err ? err.code : typeof duration));
expect(connectedReturn).toBe(true);
expect(await settled(connectedPing.promise)).toBe("number");
} finally {
client.destroy();
server.close();
}
});
Loading