Commit cb4cba6d0b6 for nodejs
commit cb4cba6d0b676d0e1a329126e66ad98bbf928250
Author: Matteo Collina <hello@matteocollina.com>
Date: Mon Nov 16 22:47:08 2026 +0100
http2: do not end compat requests reset before END_STREAM
When the peer reset a stream before sending END_STREAM, the compat
`Http2ServerRequest` still pushed EOF from its 'close' handler, so it
emitted 'end' for a truncated body (on main even after 'error' and
'close'). Unlike http1, where an aborted `IncomingMessage` is destroyed
and never emits 'end', applications listening for 'end' then processed
the partial body as if it were complete.
Record in `onStreamClose()` that the peer closed the stream before
END_STREAM, since `destroy()` ends the readable side afterwards, and
destroy the request instead of ending it in that case. Requests whose
body was complete before the reset still end normally.
Signed-off-by: Matteo Collina <hello@matteocollina.com>
PR-URL: https://github.com/nodejs/node/pull/67061
Reviewed-By: Robert Nagy <ronagy@icloud.com>
Reviewed-By: Filip Skokan <panva.ip@gmail.com>
Reviewed-By: Gürgün Dayıoğlu <hey@gurgun.day>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Tim Perry <pimterry@gmail.com>
diff --git a/lib/internal/http2/compat.js b/lib/internal/http2/compat.js
index 2eedfd39010..34f16576da6 100644
--- a/lib/internal/http2/compat.js
+++ b/lib/internal/http2/compat.js
@@ -57,6 +57,7 @@ const {
kSocket,
kRequest,
kProxySocket,
+ kIncomplete,
assertValidPseudoHeader,
getAuthority,
} = require('internal/http2/util');
@@ -154,9 +155,12 @@ function onStreamTrailers(trailers, flags, rawTrailers) {
}
function onStreamEnd() {
- // Cause the request stream to end as well.
+ // Cause the request stream to end as well. Skip when the body is
+ // incomplete (the peer never sent END_STREAM and the stream was torn down,
+ // e.g. reset, local close, or session teardown); destroying the readable on
+ // close emits 'end' spuriously, so it must not reach the compat request.
const request = this[kRequest];
- if (request !== undefined)
+ if (request !== undefined && !this[kIncomplete])
this[kRequest].push(null);
}
@@ -291,15 +295,24 @@ function onStreamCloseRequest() {
const state = req[kState];
state.closed = true;
+ this[kProxySocket] = null;
+ this[kRequest] = undefined;
+
+ // The peer closed the stream before END_STREAM, so the request body is
+ // incomplete. Like http1's IncomingMessage on abort, destroy the request
+ // instead of ending it, so 'end' is not emitted for a truncated body.
+ // destroy() emits 'close'.
+ if (this[kIncomplete]) {
+ req.destroy();
+ return;
+ }
+
req.push(null);
// If the user didn't interact with incoming data and didn't pipe it,
// dump it for compatibility with http1
if (!state.didRead && !req._readableState.resumeScheduled)
req.resume();
- this[kProxySocket] = null;
- this[kRequest] = undefined;
-
req.emit('close');
}
diff --git a/lib/internal/http2/core.js b/lib/internal/http2/core.js
index d3695145115..44822c2ea01 100644
--- a/lib/internal/http2/core.js
+++ b/lib/internal/http2/core.js
@@ -156,6 +156,7 @@ const {
kStrictSingleValueFields,
kSocket,
kRequest,
+ kIncomplete,
kProtocol,
kProxySocket,
MAX_ADDITIONAL_SETTINGS,
@@ -655,6 +656,10 @@ function onStreamClose(code, peerReset) {
const cleanCode = code === NGHTTP2_NO_ERROR || code === NGHTTP2_CANCEL;
if (!peerReadableEnded) {
+ // The peer closed the stream before END_STREAM, so the incoming message
+ // is incomplete. Bear in mind we must not 'end' the compat request. The
+ // decision is recorded in _destroy() via this._readableState.ended, which
+ // is the same signal as peerReadableEnded here.
stream.destroy(cleanCode ?
new ERR_HTTP2_STREAM_ABORTED() :
new ERR_HTTP2_STREAM_ERROR(nameForErrorCode[code] || code));
@@ -2698,6 +2703,14 @@ class Http2Stream extends Duplex {
if (hasHandle)
handle.rstStream(code);
}
+
+ // If the peer never sent END_STREAM, the readable side was torn down
+ // before reaching EOF, so the incoming message is incomplete. _destroy()
+ // always ends the readable below, so record it here for the compat layer
+ // (onStreamCloseRequest). Doing it in one place covers remote reset,
+ // local close, and unexpected session teardown alike.
+ if (!this._readableState.ended)
+ this[kIncomplete] = true;
this.push(null);
diff --git a/lib/internal/http2/util.js b/lib/internal/http2/util.js
index f0f80aa175e..4d5db68ac23 100644
--- a/lib/internal/http2/util.js
+++ b/lib/internal/http2/util.js
@@ -46,6 +46,7 @@ const kSocket = Symbol('socket');
const kProtocol = Symbol('protocol');
const kProxySocket = Symbol('proxySocket');
const kRequest = Symbol('request');
+const kIncomplete = Symbol('incomplete');
const {
NGHTTP2_NV_FLAG_NONE,
@@ -1003,6 +1004,7 @@ module.exports = {
kStrictSingleValueFields,
kSocket,
kProtocol,
+ kIncomplete,
kProxySocket,
kRequest,
MAX_ADDITIONAL_SETTINGS,
diff --git a/test/parallel/test-http2-compat-serverrequest-end-after-abort.js b/test/parallel/test-http2-compat-serverrequest-end-after-abort.js
new file mode 100644
index 00000000000..3652e0a5178
--- /dev/null
+++ b/test/parallel/test-http2-compat-serverrequest-end-after-abort.js
@@ -0,0 +1,152 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+ common.skip('missing crypto');
+
+// A request whose stream is reset by the peer before END_STREAM has an
+// incomplete body. Like http1, the compat request must not emit 'end' for it.
+
+const assert = require('assert');
+const http2 = require('http2');
+const { finished } = require('stream');
+
+const codes = [
+ http2.constants.NGHTTP2_NO_ERROR,
+ http2.constants.NGHTTP2_CANCEL,
+];
+
+const server = http2.createServer(common.mustCall((req, res) => {
+ // Tell the client the partial body arrived, so it can reset the stream.
+ req.once('data', common.mustCall(() => res.writeHead(200).flushHeaders()));
+ req.on('end', common.mustNotCall());
+ req.on('aborted', common.mustCall());
+ req.on('error', common.expectsError({ code: 'ERR_HTTP2_STREAM_ABORTED' }));
+ req.on('close', common.mustCall(() => {
+ assert.strictEqual(req.aborted, true);
+ assert.strictEqual(req.readableEnded, false);
+ }));
+ finished(req, common.mustCall((err) => {
+ assert.ok(err);
+ }));
+}, codes.length));
+
+server.listen(0, common.mustCall(() => {
+ const client = http2.connect(`http://localhost:${server.address().port}`);
+ let pending = codes.length;
+
+ for (const code of codes) {
+ const req = client.request({
+ ':method': 'POST',
+ 'content-length': '1000',
+ });
+ req.on('error', () => {});
+ req.on('close', common.mustCall(() => {
+ if (--pending === 0) {
+ client.close();
+ server.close();
+ }
+ }));
+ // Send part of the body, then reset the stream without END_STREAM once
+ // the server has seen it.
+ req.write('{"action":"partial"}');
+ req.on('response', common.mustCall(() => req.close(code)));
+ }
+}));
+
+// A complete body followed by a reset still ends the request normally.
+{
+ const server = http2.createServer(common.mustCall((req, res) => {
+ let body = '';
+ req.setEncoding('utf8');
+ req.on('data', (chunk) => body += chunk);
+ req.on('end', common.mustCall(() => {
+ assert.strictEqual(body, 'complete');
+ res.writeHead(200).flushHeaders();
+ }));
+ req.on('error', common.mustNotCall());
+ }));
+
+ server.listen(0, common.mustCall(() => {
+ const client = http2.connect(`http://localhost:${server.address().port}`);
+ const req = client.request({ ':method': 'POST' });
+ req.on('error', () => {});
+ req.on('response', common.mustCall(() => {
+ req.close(http2.constants.NGHTTP2_CANCEL);
+ }));
+ req.on('close', common.mustCall(() => {
+ client.close();
+ server.close();
+ }));
+ req.end('complete');
+ }));
+}
+
+// A stream closed locally by the server before the peer sends END_STREAM also
+// has an incomplete body and must not emit 'end'.
+{
+ const server = http2.createServer(common.mustCall((req, res) => {
+ req.once('data', common.mustCall(() => {
+ // Tear the stream down locally while the body is still in flight.
+ req.stream.destroy();
+ }));
+ req.on('end', common.mustNotCall());
+ req.on('aborted', common.mustCall());
+ req.on('error', common.mustNotCall());
+ req.on('close', common.mustCall(() => {
+ assert.strictEqual(req.aborted, true);
+ assert.strictEqual(req.readableEnded, false);
+ }));
+ finished(req, common.mustCall((err) => {
+ assert.ok(err);
+ }));
+ }));
+
+ server.listen(0, common.mustCall(() => {
+ const client = http2.connect(`http://localhost:${server.address().port}`);
+ const req = client.request({
+ ':method': 'POST',
+ 'content-length': '1000',
+ });
+ req.on('error', () => {});
+ req.on('close', common.mustCall(() => {
+ client.close();
+ server.close();
+ }));
+ req.write('{"action":"partial"}');
+ }));
+}
+
+// An unexpected session teardown mid-body also produces an incomplete request
+// that must not emit 'end'.
+{
+ const server = http2.createServer(common.mustCall((req, res) => {
+ req.once('data', common.mustCall(() => {
+ req.stream.session.destroy();
+ }));
+ req.on('end', common.mustNotCall());
+ req.on('aborted', common.mustCall());
+ req.on('error', common.mustNotCall());
+ req.on('close', common.mustCall(() => {
+ assert.strictEqual(req.aborted, true);
+ assert.strictEqual(req.readableEnded, false);
+ }));
+ finished(req, common.mustCall((err) => {
+ assert.ok(err);
+ }));
+ }));
+
+ server.listen(0, common.mustCall(() => {
+ const client = http2.connect(`http://localhost:${server.address().port}`);
+ const req = client.request({
+ ':method': 'POST',
+ 'content-length': '1000',
+ });
+ req.on('error', () => {});
+ req.on('close', common.mustCall(() => {
+ client.close();
+ server.close();
+ }));
+ req.write('{"action":"partial"}');
+ }));
+}