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
56 changes: 40 additions & 16 deletions src/stream_base.cc
Original file line number Diff line number Diff line change
Expand Up @@ -8,6 +8,7 @@
#include "node_buffer.h"
#include "node_errors.h"
#include "node_external_reference.h"
#include "simdutf.h"
#include "string_bytes.h"
#include "util-inl.h"
#include "v8.h"
Expand Down Expand Up @@ -196,6 +197,38 @@ int StreamBase::FinishWrite(const v8::FunctionCallbackInfo<v8::Value>& args,
return res.err;
}

namespace {

// Same as StringBytes::Write(), but copies one-byte strings out with
// String::WriteOneByte(), which does not flatten them: strings written to a
// stream are often built by concatenation (e.g. HTTP headers) and not used
// again.
size_t WriteStringWithoutFlattening(Isolate* isolate,
char* buf,
size_t buflen,
Local<String> string,
enum encoding enc) {
const size_t length = string->Length();
if (length == 0) return 0;
if (string->IsOneByte()) {
if ((enc == ASCII || enc == LATIN1) && buflen >= length) {
string->WriteOneByte(isolate, 0, length, reinterpret_cast<uint8_t*>(buf));
return length;
}
if (enc == UTF8 && buflen >= 3 * length) {
// Latin-1 takes at most 2 UTF-8 bytes per char: convert from the last
// third into the first two.
char* latin1 = buf + 2 * length;
string->WriteOneByte(
isolate, 0, length, reinterpret_cast<uint8_t*>(latin1));
return simdutf::convert_latin1_to_utf8(latin1, length, buf);
}
}
return StringBytes::Write(isolate, buf, buflen, string, enc);
}

} // namespace

int StreamBase::Writev(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
Isolate* isolate = env->isolate();
Expand Down Expand Up @@ -297,11 +330,8 @@ int StreamBase::Writev(const FunctionCallbackInfo<Value>& args) {
if (!chunks->Get(context, i * 2 + 1).ToLocal(&next_chunk))
return -1;
enum encoding encoding = ParseEncoding(isolate, next_chunk);
str_size = StringBytes::Write(isolate,
str_storage,
str_size,
string,
encoding);
str_size = WriteStringWithoutFlattening(
isolate, str_storage, str_size, string, encoding);
bufs[i].base = str_storage;
bufs[i].len = str_size;
offset += str_size;
Expand Down Expand Up @@ -372,7 +402,7 @@ int StreamBase::WriteString(const FunctionCallbackInfo<Value>& args) {
if (args[2]->IsObject())
send_handle_obj = args[2].As<Object>();

// Compute the size of the storage that the string will be flattened into.
// Compute the size of the storage that the string will be written into.
// For UTF8 strings that are very long, go ahead and take the hit for
// computing their actual size, rather than tripling the storage.
size_t storage_size;
Expand All @@ -395,11 +425,8 @@ int StreamBase::WriteString(const FunctionCallbackInfo<Value>& args) {
bool try_write = HasDoTryWrite() && storage_size <= sizeof(stack_storage) &&
(!IsIPCPipe() || send_handle_obj.IsEmpty());
if (try_write) {
data_size = StringBytes::Write(isolate,
stack_storage,
storage_size,
string,
enc);
data_size = WriteStringWithoutFlattening(
isolate, stack_storage, storage_size, string, enc);
buf = uv_buf_init(stack_storage, data_size);

uv_buf_t* bufs = &buf;
Expand Down Expand Up @@ -433,11 +460,8 @@ int StreamBase::WriteString(const FunctionCallbackInfo<Value>& args) {
// Write it
bs = ArrayBuffer::NewBackingStore(
isolate, storage_size, BackingStoreInitializationMode::kUninitialized);
data_size = StringBytes::Write(isolate,
static_cast<char*>(bs->Data()),
storage_size,
string,
enc);
data_size = WriteStringWithoutFlattening(
isolate, static_cast<char*>(bs->Data()), storage_size, string, enc);
}

CHECK_LE(data_size, storage_size);
Expand Down
16 changes: 8 additions & 8 deletions src/string_bytes.cc
Original file line number Diff line number Diff line change
Expand Up @@ -468,38 +468,38 @@ Maybe<size_t> StringBytes::StorageSize(Isolate* isolate,
Local<String> str;
if (!val->ToString(isolate->GetCurrentContext()).ToLocal(&str))
return Nothing<size_t>();
String::ValueView view(isolate, str);
const size_t length = str->Length();
size_t data_size = 0;

switch (encoding) {
case ASCII:
case LATIN1:
data_size = view.length();
data_size = length;
break;

case BUFFER:
case UTF8:
// A single UCS2 codepoint never takes up more than 3 utf8 bytes.
// It is an exercise for the caller to decide when a string is
// long enough to justify calling Size() instead of StorageSize()
data_size = 3 * view.length();
data_size = 3 * length;
break;

case UCS2:
data_size = view.length() * sizeof(uint16_t);
data_size = length * sizeof(uint16_t);
break;

case BASE64URL:
data_size = simdutf::base64_length_from_binary(view.length(),
simdutf::base64_url);
data_size =
simdutf::base64_length_from_binary(length, simdutf::base64_url);
break;

case BASE64:
data_size = simdutf::base64_length_from_binary(view.length());
data_size = simdutf::base64_length_from_binary(length);
break;

case HEX:
data_size = view.length() / 2;
data_size = length / 2;
break;

default:
Expand Down
60 changes: 60 additions & 0 deletions test/parallel/test-net-write-concatenated-string.js
Original file line number Diff line number Diff line change
@@ -0,0 +1,60 @@
'use strict';
const common = require('../common');
const assert = require('assert');
const net = require('net');

// Writes concatenated strings around the size limits of the stack buffer used
// by StreamBase::WriteString() and checks the bytes on the wire.

function concat(length, base) {
let str = '';
for (let i = 0; i < length; i++)
str += String.fromCharCode(base + i % 16);
return str;
}

const cases = [];
for (const length of [0, 13, 5461, 5462, 16384, 16385]) {
// ASCII, non-ASCII Latin-1, two-byte.
for (const base of [0x61, 0xe0, 0x2000]) {
for (const encoding of ['utf8', 'latin1', 'ascii']) {
cases.push({ length, base, encoding });
}
}
}

const expected = [];

const server = net.createServer(common.mustCall((socket) => {
const chunks = [];
socket.on('data', (chunk) => chunks.push(chunk));
socket.on('end', common.mustCall(() => {
const actual = Buffer.concat(chunks);
let offset = 0;
for (const [i, buf] of expected.entries()) {
const { length, base, encoding } = cases[i];
assert.deepStrictEqual(
actual.subarray(offset, offset + buf.length),
buf,
`length ${length}, base 0x${base.toString(16)}, ${encoding}`);
offset += buf.length;
}
assert.strictEqual(offset, actual.length);
server.close();
}));
}));

server.listen(0, common.mustCall(() => {
const socket = net.connect(server.address().port);
let i = 0;
function next() {
if (i === cases.length) return socket.end();
const { length, base, encoding } = cases[i++];
const str = concat(length, base);
// Each write waits for the previous one so that it goes through
// WriteString() and not Writev().
socket.write(str, encoding, common.mustSucceed(next));
expected.push(Buffer.from(str, encoding));
}
socket.on('connect', common.mustCall(next));
}));
62 changes: 62 additions & 0 deletions test/parallel/test-net-writev-concatenated-string.js
Original file line number Diff line number Diff line change
@@ -0,0 +1,62 @@
'use strict';
const common = require('../common');
const assert = require('assert');
const net = require('net');

// Writes concatenated strings with a Buffer after each of them in a single
// StreamBase::Writev() call, like an HTTP response header followed by a Buffer
// body, and checks the bytes on the wire.

function concat(length, base) {
let str = '';
for (let i = 0; i < length; i++)
str += String.fromCharCode(base + i % 16);
return str;
}

const separator = Buffer.from('|');
const writes = [];
// Writev() reserves 3 bytes per character for UTF-8 strings of up to 65535
// characters and the exact size for longer ones.
for (const length of [0, 13, 5461, 16385, 65535, 65536]) {
// ASCII, non-ASCII Latin-1, two-byte.
for (const base of [0x61, 0xe0, 0x2000]) {
for (const encoding of ['utf8', 'latin1', 'ascii']) {
writes.push({
label: `length ${length}, base 0x${base.toString(16)}, ${encoding}`,
str: concat(length, base),
encoding,
});
}
}
}

const server = net.createServer(common.mustCall((socket) => {
const chunks = [];
socket.on('data', (chunk) => chunks.push(chunk));
socket.on('end', common.mustCall(() => {
const actual = Buffer.concat(chunks);
let offset = 0;
for (const { label, str, encoding } of writes) {
const expected = Buffer.concat([Buffer.from(str, encoding), separator]);
assert.deepStrictEqual(
actual.subarray(offset, offset + expected.length), expected, label);
offset += expected.length;
}
assert.strictEqual(offset, actual.length);
server.close();
}));
}));

server.listen(0, common.mustCall(() => {
const socket = net.connect(server.address().port, common.mustCall(() => {
// Corked writes are flushed together with Writev().
socket.cork();
for (const { str, encoding } of writes) {
socket.write(str, encoding);
socket.write(separator);
}
socket.uncork();
socket.end();
}));
}));
Loading