Commit db671bb4165 for nodejs
commit db671bb4165a1fc55adba1d70ced798887584088
Author: Tim Perry <pimterry@gmail.com>
Date: Thu Nov 19 18:41:27 2026 +0100
http2: fix eos() for HTTP/2 streams after clean end & close
Previously this could fail - not having read 'end' when the close
arrived was treated as a premature close error for finished() and
related APIs, even though the body data was cleanly ended and complete.
We now check whether there is a clean end buffered. If so, we wait
until it's read before evaluating whether the stream ended cleanly.
Signed-off-by: Tim Perry <pimterry@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/67553
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
diff --git a/lib/internal/streams/end-of-stream.js b/lib/internal/streams/end-of-stream.js
index f310cd6936f..a4eef74aa60 100644
--- a/lib/internal/streams/end-of-stream.js
+++ b/lib/internal/streams/end-of-stream.js
@@ -107,6 +107,16 @@ function getEosOnCloseError(stream, readable, readableFinished, writable, writab
return null;
}
+// A stream can report itself closed or aborted at the protocol level (e.g.
+// HTTP/2) while its complete body is still buffered and readable.
+function isEndPending(stream, readable, readableFinished, writable, writableFinished) {
+ if (stream.destroyed) return false;
+ const rState = stream._readableState;
+ const rPending = readable && !readableFinished &&
+ rState?.ended === true && !rState.errored;
+ return rPending && (!writable || writableFinished);
+}
+
// Internal only: if eos() can settle immediately, invoke the callback before
// returning cleanup. Callers must tolerate cleanup yet to be assigned.
const kEosNodeSynchronousCallback = Symbol('kEosNodeSynchronousCallback');
@@ -156,13 +166,15 @@ function eos(stream, options, callback) {
*/
let immediateResult;
if (isClosed(stream)) {
- immediateResult = getEosOnCloseError(
- stream,
- readable,
- readableFinished,
- writable,
- writableFinished,
- );
+ if (!isEndPending(stream, readable, readableFinished, writable, writableFinished)) {
+ immediateResult = getEosOnCloseError(
+ stream,
+ readable,
+ readableFinished,
+ writable,
+ writableFinished,
+ );
+ }
} else if (wState?.errorEmitted || rState?.errorEmitted) {
if (!willEmitClose) {
immediateResult = getEosErrored(stream);
@@ -270,6 +282,12 @@ function eos(stream, options, callback) {
}
};
+ const onaborted = () => {
+ if (!isEndPending(stream, readable, readableFinished, writable, writableFinished)) {
+ onclose();
+ }
+ };
+
const onrequest = () => {
stream.req.on('finish', onfinish);
};
@@ -291,7 +309,7 @@ function eos(stream, options, callback) {
// Not all streams will emit 'close' after 'aborted'.
if (!willEmitClose && typeof stream.aborted === 'boolean') {
- stream.on('aborted', onclose);
+ stream.on('aborted', onaborted);
}
stream.on('end', onend);
@@ -303,7 +321,7 @@ function eos(stream, options, callback) {
cleanup = () => {
callback = nop;
- stream.removeListener('aborted', onclose);
+ stream.removeListener('aborted', onaborted);
stream.removeListener('complete', onfinish);
stream.removeListener('abort', onclose);
stream.removeListener('request', onrequest);
diff --git a/test/parallel/test-http2-buffered-response-after-close.js b/test/parallel/test-http2-buffered-response-after-close.js
new file mode 100644
index 00000000000..59a10ebb737
--- /dev/null
+++ b/test/parallel/test-http2-buffered-response-after-close.js
@@ -0,0 +1,79 @@
+'use strict';
+
+// A client stream that closed normally can still hold its whole response in
+// the readable buffer. Consuming it from then on must succeed rather than
+// report ERR_STREAM_PREMATURE_CLOSE.
+// Refs: https://github.com/nodejs/node/issues/65677
+
+const common = require('../common');
+if (!common.hasCrypto)
+ common.skip('missing crypto');
+
+const assert = require('assert');
+const http2 = require('http2');
+const { once } = require('events');
+const { Writable } = require('stream');
+const { finished, pipeline } = require('stream/promises');
+const { text } = require('stream/consumers');
+const { setImmediate: setImmediateAsync } = require('timers/promises');
+
+const body = 'complete response';
+
+const consumers = {
+ async asyncIterator(request) {
+ let received = '';
+ for await (const chunk of request)
+ received += chunk;
+ return received;
+ },
+ async finishedThenData(request) {
+ let received = '';
+ const done = finished(request, { writable: false });
+ request.on('data', (chunk) => { received += chunk; });
+ await done;
+ return received;
+ },
+ async pipeline(request) {
+ let received = '';
+ await pipeline(request, new Writable({
+ write(chunk, encoding, callback) {
+ received += chunk;
+ callback();
+ },
+ }));
+ return received;
+ },
+ text,
+};
+
+const server = http2.createServer();
+server.on('stream', (stream) => {
+ stream.resume();
+ stream.on('end', () => {
+ stream.respond({ ':status': 200 }, { waitForTrailers: true });
+ stream.on('wantTrailers', () => stream.sendTrailers({ 'grpc-status': '0' }));
+ stream.end(body);
+ });
+});
+
+server.listen(0, common.mustCall(async () => {
+ const session = http2.connect(`http://localhost:${server.address().port}`);
+
+ for (const [name, consume] of Object.entries(consumers)) {
+ const request = session.request({ ':method': 'POST' });
+ request.end('request');
+ await once(request, 'response');
+
+ // Attempt to read the response _after_ the server has cleanly closed the stream:
+ while (!request.closed)
+ await setImmediateAsync();
+
+ assert.strictEqual(request.rstCode, http2.constants.NGHTTP2_NO_ERROR);
+ assert.strictEqual(request.destroyed, false);
+ assert.strictEqual(request.readableLength, Buffer.byteLength(body));
+ assert.strictEqual(await consume(request), body, name);
+ }
+
+ session.close();
+ server.close();
+}));
diff --git a/test/parallel/test-stream-finished-protocol-close.js b/test/parallel/test-stream-finished-protocol-close.js
new file mode 100644
index 00000000000..468f11c835f
--- /dev/null
+++ b/test/parallel/test-stream-finished-protocol-close.js
@@ -0,0 +1,93 @@
+'use strict';
+
+// Some streams (e.g. Http2Stream) report `closed` or emit 'aborted' at the
+// protocol level while their complete body is still buffered. That body is
+// still consumable, so eos() must wait for 'end' rather than reporting a
+// premature close.
+
+const common = require('../common');
+const assert = require('assert');
+const { Duplex, Readable, finished } = require('stream');
+
+function createStream(Type = Readable) {
+ const stream = new Type({ read() {}, write() {}, autoDestroy: false });
+ stream.aborted = false;
+ let protocolClosed = false;
+ Object.defineProperty(stream, 'closed', {
+ get: () => protocolClosed,
+ set: (value) => { protocolClosed = value; },
+ });
+ return stream;
+}
+
+{
+ // 'aborted' after the readable ended, with eos() already attached.
+ const stream = createStream();
+ stream.push('body');
+ finished(stream, common.mustSucceed(() => {
+ assert.strictEqual(stream.readableEnded, true);
+ }));
+ stream.push(null);
+ stream.aborted = true;
+ stream.emit('aborted');
+ setImmediate(common.mustCall(() => stream.resume()));
+}
+
+{
+ // Already closed when eos() is attached, consumed on a later tick.
+ const stream = createStream();
+ stream.push('body');
+ stream.push(null);
+ stream.closed = true;
+ let received = '';
+ finished(stream, common.mustSucceed(() => {
+ assert.strictEqual(received, 'body');
+ }));
+ setImmediate(common.mustCall(() => {
+ stream.on('data', (chunk) => { received += chunk; });
+ }));
+}
+
+{
+ // 'aborted' before the readable ended is still a premature close.
+ const stream = createStream();
+ stream.push('body');
+ finished(stream, common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ERR_STREAM_PREMATURE_CLOSE');
+ }));
+ stream.aborted = true;
+ stream.emit('aborted');
+}
+
+{
+ // Closed before the readable ended is still a premature close.
+ const stream = createStream();
+ stream.push('body');
+ stream.closed = true;
+ finished(stream, common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ERR_STREAM_PREMATURE_CLOSE');
+ }));
+}
+
+{
+ // Destroyed before the buffered body is consumed is a premature close.
+ const stream = createStream();
+ stream.push('body');
+ stream.push(null);
+ stream.closed = true;
+ finished(stream, common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ERR_STREAM_PREMATURE_CLOSE');
+ }));
+ setImmediate(common.mustCall(() => stream.destroy()));
+}
+
+{
+ // A Duplex with an unfinished writable side is still a premature close.
+ const stream = createStream(Duplex);
+ stream.push('body');
+ stream.push(null);
+ stream.closed = true;
+ finished(stream, common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ERR_STREAM_PREMATURE_CLOSE');
+ }));
+}