Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
10 changes: 10 additions & 0 deletions lib/internal/stream_base_commons.js
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,7 @@

const {
Array,
ArrayBufferPrototypeGetDetached,
Symbol,
} = primordials;

Expand Down Expand Up @@ -188,6 +189,15 @@ function onStreamRead(arrayBuffer) {
if (isUint8Array(nextBuf))
stream[kBuffer] = ret = nextBuf;
}
// If the buffer that will be reused for the next read was detached during
// the callback (e.g. by transferring a view into a byte `ReadableStream`),
// it can no longer be safely written to. Stop reading instead of handing
// the stale address back to the native read path.
const reusableBuf = stream[kBuffer];
if (isUint8Array(reusableBuf) &&
ArrayBufferPrototypeGetDetached(reusableBuf.buffer)) {
result = false;
}
} else {
const offset = streamBaseState[kArrayBufferOffset];
const buf = new FastBuffer(arrayBuffer, offset, nread);
Expand Down
7 changes: 6 additions & 1 deletion src/stream_base.cc
Original file line number Diff line number Diff line change
Expand Up @@ -163,7 +163,9 @@ int StreamBase::UseUserBuffer(const FunctionCallbackInfo<Value>& args) {
CHECK(Buffer::HasInstance(args[0]));

uv_buf_t buf = uv_buf_init(Buffer::Data(args[0]), Buffer::Length(args[0]));
PushStreamListener(new CustomBufferJSListener(buf));
Local<ArrayBuffer> array_buffer = args[0].As<v8::ArrayBufferView>()->Buffer();
PushStreamListener(
new CustomBufferJSListener(array_buffer->GetBackingStore(), buf));
return 0;
}

Expand Down Expand Up @@ -795,8 +797,11 @@ void CustomBufferJSListener::OnStreamRead(ssize_t nread, const uv_buf_t& buf) {
StreamBase::SKIP_NREAD_CHECKS);
Local<Value> next_buf_v;
if (ret.ToLocal(&next_buf_v) && !next_buf_v->IsUndefined()) {
Local<ArrayBuffer> array_buffer =
next_buf_v.As<v8::ArrayBufferView>()->Buffer();
buffer_.base = Buffer::Data(next_buf_v);
buffer_.len = Buffer::Length(next_buf_v);
backing_store_ = array_buffer->GetBackingStore();
}
}

Expand Down
10 changes: 9 additions & 1 deletion src/stream_base.h
Original file line number Diff line number Diff line change
Expand Up @@ -211,9 +211,17 @@ class CustomBufferJSListener : public ReportWritesToJSStreamListener {
void OnStreamRead(ssize_t nread, const uv_buf_t& buf) override;
void OnStreamDestroy() override { delete this; }

explicit CustomBufferJSListener(uv_buf_t buffer) : buffer_(buffer) {}
explicit CustomBufferJSListener(
std::shared_ptr<v8::BackingStore> backing_store, uv_buf_t buffer)
: backing_store_(std::move(backing_store)), buffer_(buffer) {}

private:
// Retain the backing store for the lifetime of the listener. The raw address
// in `buffer_` is derived from it, so retaining the backing store guarantees
// the address does not dangle even if application code later transfers (and
// thereby detaches) the buffer, e.g. by enqueuing a view into a byte
// `ReadableStream`.
std::shared_ptr<v8::BackingStore> backing_store_;
uv_buf_t buffer_;
};

Expand Down
77 changes: 77 additions & 0 deletions test/parallel/test-net-onread-buffer-detached.js
Original file line number Diff line number Diff line change
@@ -0,0 +1,77 @@
'use strict';

const common = require('../common');
const net = require('net');
const assert = require('assert');

// Regression test.
//
// When an `onread` callback transfers a view of the reusable buffer into a byte
// `ReadableStream`, the transfer detaches the buffer's backing store. The socket
// must not keep writing subsequent peer data into the detached backing store,
// otherwise it corrupts the chunk the application has retained.

let controller;
const stream = new ReadableStream({
type: 'bytes',
start(c) {
controller = c;
},
});
const reader = stream.getReader();

const server = net.createServer(common.mustCall((socket) => {
socket.setNoDelay(true);
socket.write('first');
// Send more data shortly after the client transfers the first chunk.
const timer = setTimeout(() => {
socket.write('Z'.repeat(1024));
}, 50);
socket.on('close', () => clearTimeout(timer));
socket.on('error', common.mustNotCall());
}));

server.listen(0, common.mustCall(() => {
const port = server.address().port;

let transferred = false;

const client = net.createConnection({
host: '127.0.0.1',
port,
onread: {
buffer: Buffer.alloc(4096),
callback(nread, buf) {
// Enqueueing a view transfers (and thereby detaches) the underlying
// ArrayBuffer. An affected binary then keeps writing later peer data
// over this chunk's memory.
if (transferred) return;
transferred = true;
const view = new Uint8Array(buf.buffer, buf.byteOffset, nread);
controller.enqueue(view);
},
},
});

client.on('error', common.mustNotCall());

(async () => {
const { value: chunk, done } = await reader.read();
assert.strictEqual(done, false);

// The first peer write ("first", 5 bytes) is delivered intact.
assert.strictEqual(chunk[0], 0x66); // 'f'
assert.strictEqual(Buffer.from(chunk).toString(), 'first');

// Give the second peer write time to reach the client. Reading has stopped,
// so the retained chunk must not be overwritten.
await new Promise((resolve) => setTimeout(resolve, 200));

assert.strictEqual(chunk[0], 0x66,
`retained chunk was corrupted: 0x${chunk[0].toString(16)}`);
assert.strictEqual(Buffer.from(chunk).toString(), 'first');

client.end();
server.close();
})().then(common.mustCall());
}));
Loading